feat(spec,rest,lint): an import mapping target may name a declared part of a compound field (mailing_address.street)

[objectstack-fleet]

Fixes #20149

Clause-②: yes

What this does

The maintainer's ruling on #20149 (comment 5852138019, 「同意」):

Ruled: A — a mapping target may name a declared part of a compound field (mailing_address.street); the importer assembles the parts into one value; the part names are the closed set the value schema declares.

An import mapping could write each source column to one flat field only, so nothing could build an address value from the street / city / state / postal code / country columns a spreadsheet carries. Now a fieldMapping[].target may name field.part, and the import door assembles every part one row maps into ONE value under the field's key, before the engine sees the row.

It extends the ONE verdict #20150 built, at the arm that PR marked. There is no second predicate.

• @objectstack/spec (packages/spec/src/data/import-mapping-target.ts):
  • judgeImportMappingTarget gains the { kind: 'part', target, field, part } arm.
  • indexImportMappingTargets carries each compound field's parts on a new parts map, read from the field's stored value schema (valueSchemaFor). The part names are never listed by hand.
  • A dotted target that stays refused answers unknown with a head (what the text before the dot names, and its parts when it is compound), so every door can name the legal parts.
  • unknownImportMappingTargets gives each refused target a reason: unknown, or collides for a part of a field the same mapping also writes whole.
  • ImportFieldMappingSchema.target declares the part path in its .describe() and docblock. The generated reference page, api-surface/ and export-origins/ are regenerated.
• @objectstack/rest (import-mapping.ts, import-prepare.ts):
  • applyMappingToRows takes the object definition, trimWhitespace and nullValues, and assembles parts from every transform: none, map, constant, join, and each element of a split.
  • refuseUnknownMappingTargets names the legal parts in its refusal. It still answers 400 INVALID_FIELD, before any row.
  • isBlank is exported from import-coerce.ts, so a blank part is judged by the same rule as a blank cell.
• @objectstack/lint (validate-mapping-target-fields.ts): the message "a dotted path into a field's value is not a target" is gone, because it is false for a declared part. The rule now reports the three refused cases, each with the legal parts.
• Docs: in content/docs/data-modeling/import-mappings.mdx the target row said "Target field name(s)", which is now false. It is rewritten. Only the body is edited; the frontmatter is held by PR docs(content): apply the approved search-intent title rule to 169 authored pages, short nav labels kept via navTitle #20170.

Decisions, each from a measurement

H1: which fields are compound. I checked every one of the 49 FieldType values through valueSchemaFor. Two stored value schemas are closed objects (catchall: never):

• address: seven parts (street, city, state, postalCode, country, countryCode, formatted). Every part is an optional string.
• location: lat and lng are required numbers; altitude and accuracy are optional numbers.

A field counts as compound when its value schema is a closed object whose every part is an optional string. That selects address only. location is excluded, as the ruling asked me to decide and record:

• LocationValueSchema refuses { lat: '37.7', lng: '-122.4' } (strings) and { lat: 37.7 } (no lng).
• On the ADR-0104 warn-first write path, the engine admits a value that fails its value schema and only warns. I measured this below with an address part holding a number.
• So a location assembled from text cells would be stored with the wrong type, and nothing would refuse it. With optional-string parts, every subset of text cells is a valid value by construction.

The census test pins the whole set against FieldType.options.

H2: what one row assembles. Measured through the real engine (sqlite, JSON rows, no mapping) at 055d4b66e9, with the same result on the dry run and the commit:

value sent	dry run	commit	read back
{ street, city } (partial)	ok	ok	{ street, city }
{ street: '', city } (empty part)	ok	ok	{ street: '', city }
{ postalCode: 12345 } (wrong type)	ok, with warning invalid_type	ok	{ postalCode: 12345 }
update { city } over { street, city }		ok	{ city } (the stored value is replaced whole)

The assembly rule, stated in applyMappingToRows' docblock and the docs row:

• A blank part cell contributes nothing. Blank means empty, whitespace, or a nullValues token.
  • The schema would accept street: '', but a blank flat cell leaves its field unset, and a blank part does the same one level down.
• A string part is trimmed under trimWhitespace, as a flat text cell is. Coercion never reaches inside a compound value, so the trim happens in the assembly.
• If every part a row maps is blank, the field is left unset.
• Otherwise the assembled object is the field's whole new value. On an update it replaces the stored one.

Whole field and part together. When a mapping writes mailing_address and also mailing_address.street, both write the same key of one row. They are refused as reason: 'collides' at all three doors, naming where the whole field is written. A repeated part target follows the same last-write rule as a repeated flat target.

One door. The dry run and the commit both reach the assembly through prepareImportRequest, so they judge the same assembled row. objectstack validate asks the same spec verdict.

H5: census of dotted targets at base 3875ae6773:

• The repo's one import mapping, examples/app-showcase showcase_inquiry_feed (5 entries), has no dotted target.
• No skills/ or docs page carries a dotted fieldMapping target.
• Every dotted target: hit in the tree belongs to another schema: action or form targets, API endpoint inputMapping / outputMapping, and the seed loader.
• hotcrm (the card's origin, hotcrm#1836) is NOT MEASURED from here.

Pins (the pin sweep)

• Flipped:
  • import mapping: a fieldMapping.target that names no field passes objectstack validate and the dry run, then fails every row on commit #20150 pinned mailing_address.street as unknown in import-mapping-target.test.ts, and as a finding in validate-mapping-target-fields.test.ts, on an object that declares that address field.
  • Both now assert the new meaning: all seven parts answer part, and the card's full address template is green at validate.
  • The import mapping: a fieldMapping.target that names no field passes objectstack validate and the dry run, then fails every row on commit #20150 integration pin keeps refusing mailing_address.street on task, which declares no such field. Its comment now says why.
• New, real engine (import-integration.test.ts, sqlite):
  • The customer template's five columns over three rows (full, partial, all blank).
  • The dry run and the commit agree row for row: ok 3 each.
  • Read back: one address object, a two-part address, and an unset field.
  • An unknown part and a dotted path on a text field are refused on both paths with identical bodies and the part list named, and nothing is written.
  • The whole-plus-part collision is refused on both paths.
  • The control mapping with no dotted target passes on both.
• Unit: the assembly rule in import-mapping.test.ts (blank, trim, trimWhitespace: false, every transform, two compound fields kept apart, no object definition means no part reading). The door's three refusal texts. The lint rule's three refusals.

Tests (all through os-verify-lock.sh, shared box; tree f21f41dbea)

• @objectstack/spec: vitest run --project local: 542 files, 15945 passed, 2 todo. typecheck (tsc, scripts, test layer): exit 0.
• @objectstack/rest: vitest run --project local: 199 files, 3569 passed, 1 skipped. typecheck (tsc and test layer): exit 0. The repo project is declared to CI.
• @objectstack/lint: vitest run: 109 files, 4236 passed. typecheck: exit 0.
• @objectstack/cli (unit): test/validate-build-gate-parity.test.ts: 22 passed. The integration layer is declared to CI.
• ESLint over the 10 changed .ts files (--no-inline-config --format json): 10 files, 0 errors, 0 warnings.
  • The population is the config's **/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs} minus the build directories, which all 10 files fall under.
  • eslint.config.mjs enables no type-aware linting (no parserOptions.project), so this diff cannot move the verdict on any file it does not touch.
  • The repo-wide pnpm lint is CI's.

Ablations (one-shot; each through scripts/ablation-replace.mjs, anchor hit 1, blob changed, restored to the HEAD blob with git diff HEAD empty)

• A. The spec part arm answers nothing (import-mapping-target.ts): 3 red, 18 green in import-mapping-target.test.ts. The red tests are the part arm, the address-by-parts mapping and the collision.
• B. The rest assembly is off (import-mapping.ts): 5 red, 57 green.
  • 4 red are the assembly unit tests; the control stays green.
  • The fifth is the integration test. With assembly off, the dry run still answered ok 3 while the commit answered ok 1, errors 2. That is the card's own dry-run-versus-commit defect, reproduced.
• C. The lint dotted reason is dropped (validate-mapping-target-fields.ts): 2 red, 11 green (the unknown-part and no-parts refusals).

Gates

node scripts/pm/dispatch-gates.mjs --repo objectstack-ai/objectstack --commands derived 108 families at f21f41dbea, and --ran reconciles them: 105 run green, 3 NOT MEASURED, 0 unrun.

• NOT MEASURED, each exit 3 (PREREQUISITE NOT MET):
  • check:skill-examples needs a client-react build. The shared lock never granted one inside its budget.
  • check:dual-build-cjs-loads and check:type-check-debt read a whole-repo build that this worktree does not have.
• check:generated: all 15 artifacts are up to date after gen:api-surface, gen:export-origins and gen:docs, which are committed.
• check:adr-0087-registration: green. The changeset declares a widening only (Clause-②: yes), so no disposition marker applies.
• A mergeability probe against origin/main ab820016b3, from a bare clone with no regen driver: clean.

Acceptance notes

• Only address is compound for import. A location field still imports whole, as one JSON object. Adding it would need a per-part number coercion and a required-part check. Carrier: none.
• A JSON-format row can put a non-string value in a part, such as a number for postalCode. That value passes through to the engine's value-shape check, which admits it with a warning on a warn-first deployment (measured above). This is the posture every structured value on the import path already has. Carrier: none.
• On an update, the assembled value replaces the stored address whole (measured). Merging parts into the stored value would be a new decision. It is documented in the docs row and the changeset. Carrier: none.
• The collision refusal travels under the existing rule id mapping-target-field-unknown and the existing door code INVALID_FIELD. No new rule id or error code was minted.
• The spec verdict is shared. The door and the lint rule each phrase their own sentence from it (head.parts, index.parts), as import mapping: a fieldMapping.target that names no field passes objectstack validate and the dry run, then fails every row on commit #20150 left them.

---

Generated by Claude Code

[github-actions]

📓 Docs Drift Check

This PR changes 3 package(s): @objectstack/lint, @objectstack/rest, @objectstack/spec, touching 31 documentable anchor(s). ⚠️ 2 changed file(s) yielded no anchor (packages/spec/api-surface/data.json, packages/spec/export-origins/data.json), so the pages documenting them are NOT COVERED by this run — this is not a clean bill of health for those files.

25 hand-written doc(s) name something this change touched — list omitted above 15 rows. Re-derive on the tree named below: node scripts/docs-audit/affected-docs.mjs --json fdb26698f975511a01a01f53d506058977db7cef.

⛔ 2 release-owned page(s) also affected — read-only, see AGENTS.md Documentation Guardrails.

What this run could not see

• 2 changed file(s) yielded no anchor (packages/spec/api-surface/data.json, packages/spec/export-origins/data.json) — pages documenting those are invisible to this run
• 4 name(s) were too generic to anchor anything (single lowercase words)
• the SDK route bridge reached 54 of 206 client-bound route-ledger rows — the other 152 have no registrar path: tail to select them, so pages documenting THEIR client methods cannot appear above, on this or any run. Of those 152: 0 are remediable by widening that discovery convention (an in-repo file declares the path; the convention did not scan it); 55 are structural — on a ledger where NOT ONE row is declared in-repo, so no discovery change reaches them at any price; 97 are undecided (no in-repo declaration, on a ledger that has other in-repo registrars — absence and an unreadable spelling are not distinguishable here). The rows themselves: node scripts/docs-audit/affected-docs.mjs --bridge-coverage
• a page that states a rule by its inputs shares no identifier with the emitter that implements the rule, so an emitter-only diff cannot list it — not on this run and not on any run. Measured on fix(driver-sql): emit varchar(maxLength) for a text field a declared index keys on #11430: content/docs/protocol/objectql/types.mdx documents the text-family column mapping by the ObjectQL type names it maps FROM (text / textarea / html) while the diff changed createColumn; it went unlisted, and it was the page that diff falsified, in four places. No shared token exists to detect this on, so a rule your change carries has to be re-read by hand in the pages that restate it.
• a key NAME is not a key, so the hand re-read the line above prescribes can land on the wrong schema. The same spelling is authorable on one governed type and a [REMOVED] tombstone on another for each of active, aria, joins, objects, template, tools and version (censused on [finding] tools is a key on BOTH AgentSchema (tombstoned, dead) and SkillSchema (live, cloud-attested), so a name-based search attributes skill examples to the agent key — it produced a false stop-the-line alarm on PR #19059 #19093 over the liveness ledger's governed types, top-level keys); nothing in a search result distinguishes the two, so a grep hit on a LIVE example reads as evidence about the DEAD key. Measured on fix(spec): the agent.tools liveness row says dead — it claimed live on a key the schema tombstoned #19059: content/docs/ai/agents.mdx was reported as contradicting the agent.tools tombstone over its tools: example at :161, which is inside the defineSkill({ block opened at :155 — the page was already correct. Settle ownership by PARSING the value against both schemas, never by the name: that literal PASSES SkillSchema, and as an AgentSchema it FAILS at tools with the tombstone prescription. ⛔ These names are not the whole class — a key retired through a .strict() guidance map leaves no tombstone in the walked shape and none of them here (tool.category, live as AIToolDefinition.category).

Coarse fallback — 138 page(s) merely mention a changed package (the pre-#9192 predicate, kept for the deliberately-wide backstop): node scripts/docs-audit/affected-docs.mjs --json fdb26698f975511a01a01f53d506058977db7cef → packageMentionDocs.

Which tree this was computed on

This run read content/docs from f0403634169759059d809c2bd1bf41c1e5e89fc3 — the merge of head e652a77395cfd4a2ad83724f84a68fbaa08ae2ee into base fdb26698f975511a01a01f53d506058977db7cef, which is what actions/checkout gives a pull_request run. Not the PR head.

A worktree cut from an older main holds a different content/docs, so re-deriving there can legitimately return a different list — that is a different tree, not a wrong row. To answer on the same tree:

# while this PR is open — GitHub drops the merge commit once it closes
git fetch origin f0403634169759059d809c2bd1bf41c1e5e89fc3 && git checkout f0403634169759059d809c2bd1bf41c1e5e89fc3
# afterwards, rebuild it from the two parents, which stay fetchable
git fetch origin fdb26698f975511a01a01f53d506058977db7cef e652a77395cfd4a2ad83724f84a68fbaa08ae2ee && git checkout -B drift-repro fdb26698f975511a01a01f53d506058977db7cef && git merge --no-ff e652a77395cfd4a2ad83724f84a68fbaa08ae2ee

node scripts/docs-audit/affected-docs.mjs --json fdb26698f975511a01a01f53d506058977db7cef

⚠️ That checkout carried uncommitted changes, so the commit above does not fully identify what was read.

Advisory only, and a precision-first one (#9192): a page is listed because it names a
symbol, wire route or SDK method this diff touched — not because it mentions a changed
package. Each row says which anchor put it there, so a wrong row is reportable rather than
merely annoying. To re-verify, run the docs-accuracy-audit workflow scoped to these files:
node scripts/docs-audit/affected-docs.mjs fdb26698f975511a01a01f53d506058977db7cef → pass the list as
args.docs, on the commit named under Which tree this was computed on.

[objectstack-fleet]

Contract review

Served-tier: 41/41 CONTRACT_REVIEW_TIER
Head-sha: f21f41dbeac82a005d0eed61d9d0a79523da193e

① Derived judgments

BLOCKING (5/1). The collision refusal lists no legal parts, and three texts say it does. Ruling item 3: "a refusal names the field and lists the legal parts." packages/rest/src/import-mapping.ts gates the parts sentence on if (unknown.length > 0) sentences.push(... partsHint(objectSchema)), so a collision-only refusal carries none; the lint collision finding's hint is exactly Map the field whole or by its parts, not both. (pinned in validate-mapping-target-fields.test.ts line 120, no part list in message or hint). False at head: changeset "reports what stays refused, naming the legal parts each time"; lint docblock "names the legal parts each time: ... and a part of a field the same mapping also writes whole"; rest docblock "What stays refused here, each naming the parts that ARE legal: ... a part of a field the same mapping also writes whole"; PR body "each with the legal parts". Smallest fix: emit partsHint unconditionally in refuseUnknownMappingTargets and append the compound list to the lint collision hint, then update the two exact-string pins (import-integration.test.ts collision case, lint test line 120). Fallback: strike "each time" / "each naming" in the three texts, which leaves ruling item 3 unmet for one of three refusals.

1. One verdict: the part arm sits in judgeImportMappingTarget after index.names.has(target) (import-mapping-target.ts line 249). Rest door (refuseUnknownMappingTargets) and applyMappingToRows both read the spec verdict; lint reads unknownImportMappingTargets and its only indexOf('.') (line 161) slices a message from a spec reason. objectstack validate runs the lint rule via reference-integrity-suite.ts:436; both import routes call prepareImportRequest (rest-server.ts 10198, 10301). Legal part: part / undefined / [] / ok 3 both paths. Unknown part: unknown with head.parts; 400 INVALID_FIELD naming seven parts; lint names seven; dry body equals commit body. Dotted on non-compound: refused at all three, lookup phrasing for reference types. Collision: reason:'collides' at all three (parts not listed, above). geo.lat: unknown, head type location, refused at all three.
2. Derived: importTargetPartsOf reads valueSchemaFor(def,'stored'), requires def type object, catchall never, every member optional string; keys from shape. Census pins ['f_address'] over FieldType.options. Ruling item 1: "whether location is included is measured by the dev against the spec and written down either way" — the exclusion is delegated; no owner needed. Nothing says "every compound field". No third strict-object stored schema exists (composite/record are z.record, stored file is an id).
3. Assembly: write() drops isBlank(value, nullValues) parts (same function coerceRow uses), trims when trimWhitespace !== false (flat cells: import-coerce.ts:427), writes the field only when non-empty. Update-replaces-whole is engine behaviour outside the diff, measured once, not pinned. Both paths take the assembled row from prepareImportRequest; the integration pin compares results row for row. split trims regardless of trimWhitespace (pre-existing).
4. No narrowing: base ab820016b3 carries import mapping: a fieldMapping.target that names no field passes objectstack validate and the dry run, then fails every row on commit #20150, so every dotted target was unknown and refused at all three doors, including the collision shape's dotted half. Flat path of applyMappingToRows is unchanged (mapped[target] = value; control pin without objectSchema). Flat-unknown refusal keeps code, status and opening sentence. yes is right.
5. Other text: mapping.zod.ts docblock "read from the field's value schema by judgeImportMappingTarget" — read by indexImportMappingTargets/importTargetPartsOf; imprecise, not false enough to block. Changeset "was refused at objectstack validate, on the dry run and on the commit" is true against main but .changeset/20150-...md is also unreleased, so a 17.4.0 reader (validate silent, dry run ok 44) meets a state no release had. Docs row and generated reference: true.
6. Pins that stay green on guard removal: update-replaces-whole (none); in importTargetPartsOf, dropping the optional check alone or the string check alone (location fails both), dropping catchall never or the empty-shape guard (no stored schema is open or empty); the unknown.length > 0 gate on partsHint (no pin either way). Ablation legs A/B/C, the trim, N/A, all-blank c3, and lookup-phrasing pins go red on removal.

② Semver level

minor for spec, rest, lint in .changeset/20149-import-mapping-compound-parts.md; Clause-②: yes on the body and changeset. Widening only: new kind:'part' member, ImportMappingTargetHead (api-surface +1), parts on the index, reason/head/wholeAt, optional third param, isBlank export (not in the rest barrel). Not yes (narrowing) per item 4. ADR-0087: check-adr-0087-registration.mjs:639-640 signals only on arm narrowing; no banner; no disposition needed — right. CI at head: 24 success, 5 skipped, 8 in progress (Test Core 1-6, Type Check workspace, Lint & Repo Gates), 0 failed at review time.

③ Boundary flags

• location whole-only: matches ruling item 1's delegation; recorded in module note, census, changeset. OK.
• JSON non-string part to warn-first check: pre-existing posture; the body's own table shows dry run "ok, with warning", commit "ok" — unpinned, CSV-only pins. OK as a note.
• Update replaces stored value whole: documented, unpinned; merge would be a new decision. OK.
• Collision under mapping-target-field-unknown / INVALID_FIELD: consistent with triage ④ "no new keys or enum values". OK.
• Each door phrases its own sentence from the shared verdict: that is where the collision refusal lost the parts list (blocking item).
• Unlisted: lookup transform on a part target assembles raw text as none would (reference resolution keys on the field, an address); not ruled, not pinned.
• Frontmatter of import-mappings.mdx held by docs(content): apply the approved search-intent title rule to 169 authored pages, short nav labels kept via navTitle #20170: respected.

Implemented-by: claude/issue-20149-import-mapping-compound-parts
Reviewed-by: session_01QcAS3qiYYZNezaxZxaUdMV

VERDICT: FAIL

[objectstack-fleet]

Contract review

Served-tier: 64/64 CONTRACT_REVIEW_TIER
Head-sha: e652a77395cfd4a2ad83724f84a68fbaa08ae2ee

① Derived judgments

1. Delta. PR re-read: head still e652a77395. git diff f21f41dbea e652a77395 --stat: 6 files, +24/−11, exactly the six named. Rest door import-mapping.ts:176: sentences.push(\Point each target at a field the object declares${partsHint(objectSchema)}.`)is now unconditional (was gated on an unknown target being present). Probe at head (tsx in a throwaway worktree, spec resolved from source, removed after): collision → "…Map the field whole or by its parts, not both. Point each target at a field the object declares, or at a declared part of a compound field as field.part (mailing_address: street, city, state, postalCode, country, countryCode, formatted)."; unknown part → "(the address field "mailing_address" declares the parts street, …, formatted)" plus the same tail;full_name.first→ "(the text field "full_name" has no parts)";account.name→ "has no parts: a dotted target never traverses a reference, so map the column to "account" with transform "lookup"";geo.lat→ "(the location field "geo" has no parts)"; every one400 INVALID_FIELDending with the parts tail. Lint:compoundPartsis built once per mapping fromindex.parts; the collision hint is exactly "Map the field whole or by its parts, not both. A declared part of a compound field is written field.part (mailing_address: street, …, formatted)."; the unknown-part, dotted and locationhints carry "or at a declared part of a compound field as field.part (mailing_address: …)" and each message names the head's parts or "with no parts". Same index, no copy: restpartsHintand lintcompoundPartsboth readindex.parts←indexImportMappingTargets←importTargetPartsOf←valueSchemaFor(def, 'stored'); git grep postalCodeover the five source files hits only the docblock atimport-mapping-target.ts:71. Pins: ablating R1 (re-gate the rest sentence) and R2 (drop the list from the lint collision hint) flipped exactly the three collision needles (rest unit import-mapping.test.ts:254, integration import-integration.test.ts:859, lint exact hint :120-122) to false and left every other case listed; restored, git status` clean.

2. Four texts, true at head. Changeset "reports what stays refused, naming the legal parts each time"; lint docblock "names the legal parts each time: … and a part of a field the same mapping also writes whole"; rest docblock "each naming the parts that ARE legal"; PR body "The rule now reports the three refused cases, each with the legal parts". mapping.zod.ts:194-198 "read from each field's value schema when indexImportMappingTargets indexes the object (its module-private importTargetPartsOf …); judgeImportMappingTarget, the one verdict every door asks, then judges a field.part target against that set": importTargetPartsOf is unexported and called only from indexImportMappingTargets; the judge reads index.parts.get(name). True.

3. Everything else (nothing moved beyond the one commit). One verdict: the part arm sits in judgeImportMappingTarget after index.names.has(target); the door, applyMappingToRows and lint all reach it (unknownImportMappingTargets or direct). Three doors: rest-server.ts:10198 and :10301 both call prepareImportRequest; the lint rule is wired at reference-integrity-suite.ts:436; the integration pin asserts dry._json equals commit._json on every refusal and row-for-row shapes on the legal template. Part set: AddressSchema is a strictObject of seven z.string().optional(); LocationValueSchema (field-value.zod.ts:395) is the only other strictObject( in the file and fails the optional-string test; census pin ['f_address'] over FieldType.options; ruling item 1 delegates location to the dev's measurement, recorded in module note, test, changeset and docs. Assembly: write() drops isBlank(value, nullValues) (the function coerceRow uses, exported, not in the rest barrel), trims when trimWhitespace !== false, sets the field only when non-empty; update-replaces-whole is engine behaviour, measured in the body, documented, unpinned. No narrowing: with no compound field partsHint is empty and the flat-unknown message is byte-identical to main's; code and status unchanged; every dotted target was already unknown on main via import mapping: a fieldMapping.target that names no field passes objectstack validate and the dry run, then fails every row on commit #20150.

4. Other sentences. Docs row, generated reference row and .describe() are true. Pre-existing looseness, not this PR's: import-mappings.mdx:97 "one entry per target field" (a split, and now a part set, writes one field from several entries) and "the verdict comes from the engine's own write-path validation" (the target refusal is the door's since import mapping: a fieldMapping.target that names no field passes objectstack validate and the dry run, then fails every row on commit #20150). Non-blocking. The body's Tests and Ablations cite tree f21f41dbea; true of that tree, with R1/R2 recorded in the dev report at head.

CI at head: 35 check runs, 33 success, 2 skipped (Console Pin Gate, Packed-tarball smoke), 0 failed.

② Semver level

.changeset/20149-import-mapping-compound-parts.md: spec, rest, lint minor; Clause-②: yes line-leading in changeset and body, the spelling CLAUSE2_KEY_LINE reads (scripts/pm/clause2-line.mjs:124). Widening only: new verdict member, ImportMappingTargetHead (api-surface +1), parts, reason/head/wholeAt, an optional third parameter, the isBlank export. check-adr-0087-registration.mjs:587 signals only on the arm narrowing; no arm, no banner, so no disposition. Right.

③ Boundary flags

• location imports whole only: ruling item 1 delegated it; recorded in four places. OK.
• JSON non-string part passes to the warn-first shape check: pre-existing posture, measured in the body, unpinned. OK.
• Update replaces the stored address whole: documented; a merge would be a new decision. OK.
• Collision under mapping-target-field-unknown / INVALID_FIELD: no new id or code, consistent with triage ④. OK.
• Each door phrases its own sentence from head.parts / index.parts: both read the one index; the collision gap is closed at head. OK.
• Unlisted in the body: a lookup transform on a part target assembles raw text; in the dev report only, neither ruled nor pinned.
• Frontmatter of import-mappings.mdx held by docs(content): apply the approved search-intent title rule to 169 authored pages, short nav labels kept via navTitle #20170: respected (the three-dot diff touches only the row). docs(content): apply the approved search-intent title rule to 169 authored pages, short nav labels kept via navTitle #20170 has since landed on main; git merge-tree --write-tree origin/main e652a77395 is clean, and the repo's merge driver asks for api-surface/data.json and export-origins/data.json to be regenerated from the merged tree, main having moved +4 lines on each.

Implemented-by: claude/issue-20149-import-mapping-compound-parts
Reviewed-by: session_01QcAS3qiYYZNezaxZxaUdMV

VERDICT: PASS