fix(spec): the page-name route is canonical for a region-level page:header

`translatePage` stops reading the id route (`pages.PAGE.components.HEADERID.*`)
for a `page:header` at region level. That route was live and PREFERRED there,
while the CLI extractor deliberately offers nothing under it for the same
component -- so every key read through it was a key no tooling ever offered,
counted or reported, and the header's `title` had two addresses while its
`subtitle` had one.

The gate mirrors the extractor's emission exception in `collectExpectedEntries`
(same shape, opposite verb), so the failure pair `walkAddressedPageComponents`
exists to prevent cannot reopen from the resolver side. A `page:header` nested
inside a container is unchanged: the page-name route does not reach it, so it
stays id-only. The walk's `addressed` arbitration is untouched -- a region-level
header's id still claims its entry and still blocks a nested namesake, which is
what the extractor does too.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01T6HeZvT9wdSJD1ZxJb5Eno

Author: claude

packages/cli/test/platform-page-i18n-parity.test.ts

@@ -352,14 +352,18 @@ describe('i18n-extract ↔ translatePage walk parity (#13109)', () => {
     // Both directions, named separately so a failure says WHICH half broke.
     expect({ offeredButIgnored: [...offered].filter((id) => !applied.has(id)).sort() })
       .toEqual({ offeredButIgnored: [] });
-    // The ONE standing exception, pre-dating this card and deliberate: a
-    // region-level `page:header`'s copy is offered under `pages.PAGE.title` /
-    // `.subtitle` instead, because emitting it here too would offer one string
-    // under two keys. The resolver still honours the id route for it, so it
-    // shows up as applied-not-offered — listed explicitly rather than filtered
-    // out of the fixture, so the exception stays visible and bounded to one id.
+    // NO standing exception any more. This list used to read `['hdr']` — a
+    // region-level `page:header` carrying an id, whose copy the extractor
+    // deliberately offers under `pages.PAGE.title` / `.subtitle` while the
+    // resolver went on honouring the id route for it and PREFERRING it. That
+    // was the second half of the failure pair `walkAddressedPageComponents`
+    // exists to prevent (the resolver reading an id the extractor omits), and
+    // the 2026-09-06 ruling (decision batch #58) closed it by making the
+    // page-name route canonical for this component. Empty in BOTH directions
+    // is now the invariant; an entry reappearing here is a regression, not an
+    // exception to document.
     expect({ appliedButNotOffered: [...applied].filter((id) => !offered.has(id)).sort() })
-      .toEqual({ appliedButNotOffered: ['hdr'] });
+      .toEqual({ appliedButNotOffered: [] });
   });
 
   it('pins the two sets by name, so a shape that stops being reachable is visible', () => {
@@ -369,11 +373,141 @@ describe('i18n-extract ↔ translatePage walk parity (#13109)', () => {
     ]);
     // `card_body_child`, `card_footer_child`, `tab_child` and `slot_child` are
     // absent from BOTH sides — the shapes `translatePage` does not descend.
+    // `hdr` — the region-level `page:header` — is absent from BOTH sides since
+    // the ruling. `nested_header` stays: a `page:header` inside a container is
+    // reached by the id route only, so the id key is the only key it has.
     expect([...idsResolverApplies(page)].sort()).toEqual([
-      'card', 'hdr', 'inner_flex', 'kpi_1', 'kpi_deep', 'kpi_label', 'nested_header', 'region_metric',
+      'card', 'inner_flex', 'kpi_1', 'kpi_deep', 'kpi_label', 'nested_header', 'region_metric',
     ]);
   });
 
+  // ── The ruled invariant, pinned directly (decision batch #58, 2026-09-06) ──
+  //
+  // Maintainer 「同意」, option 1, verbatim: "The page-name route is canonical
+  // for a region-level `page:header`. `translatePage` stops reading the id
+  // route (`pages.PAGE.components.HEADERID.*`) for a `page:header` at region
+  // level; a `page:header` nested inside a container stays id-only, as its doc
+  // already says. One component, one address — `title` and `subtitle` now
+  // follow the same rule."
+  //
+  // The set comparisons above measure `title` alone, because that is the key
+  // both fixtures carry. This case walks the WHOLE shared key list and asserts
+  // BOTH verbs of the failure pair on one component, in one place: the id key
+  // is neither OFFERED nor READ. It also pins the three things that must NOT
+  // move with it — the page-name route still translates the header, a nested
+  // `page:header` is still id-addressed, and a bundle carrying both routes
+  // resolves to the page-name one — so a regression that simply stops
+  // translating region-level headers cannot pass here either.
+  const headerRoutePage = (): Record<string, any> => ({
+    name: 'header_route_page',
+    regions: [
+      {
+        name: 'top',
+        components: [
+          // Region level, WITH an id — the shape the card measured (hotcrm's
+          // five headers all carry one).
+          { id: 'home_header', type: 'page:header', properties: { title: 'Sales Home', subtitle: 'Welcome back' } },
+        ],
+      },
+      {
+        name: 'main',
+        components: [
+          {
+            id: 'wrap',
+            type: 'page:card',
+            properties: {
+              title: 'Wrap',
+              children: [
+                // Nested — the page-name route does not reach it, so the id
+                // route is the ONLY route it has. Unchanged by the ruling.
+                { id: 'inner_header', type: 'page:header', properties: { title: 'Inner header' } },
+              ],
+            },
+          },
+        ],
+      },
+    ],
+  });
+
+  /** Every key of the shared list under one id, sentinel-valued. */
+  const everyKeyFor = (id: string): Record<string, string> =>
+    Object.fromEntries(PAGE_COMPONENT_COPY_KEYS.map((k) => [k, `ID::${id}::${k}`]));
+
+  it('neither offers nor reads the id key for a region-level `page:header` (batch #58)', () => {
+    const page = headerRoutePage();
+
+    // Half one — the extractor offers NOTHING under `components.home_header`,
+    // for any key of the shared list.
+    expect(componentRows(page).filter((r) => r.key.startsWith('home_header.'))).toEqual([]);
+
+    // Half two — the resolver reads nothing there either. The bundle offers
+    // every key of the shared list under that id; a sentinel reaching the
+    // output would mean the id route is still live for this component.
+    const idBundle = {
+      en: {
+        pages: {
+          header_route_page: {
+            components: { home_header: everyKeyFor('home_header'), wrap: everyKeyFor('wrap') },
+          },
+        },
+      },
+    } as any;
+    const viaId = translatePage(page as any, idBundle, { locale: 'en' });
+    const header = viaId.regions[0].components[0];
+    expect(header.properties).toEqual({ title: 'Sales Home', subtitle: 'Welcome back' });
+    expect(header.label).toBeUndefined();
+    // Positive control for that empty: the SAME bundle shape does reach a
+    // component the id route serves, so the two assertions above are a reading
+    // and not an inert fixture.
+    expect(viaId.regions[1].components[0].properties.title).toEqual('ID::wrap::title');
+
+    // Half three — the page-name route still translates the header. The fix is
+    // "one address", not "no address".
+    const nameBundle = {
+      en: { pages: { header_route_page: { title: 'BY-NAME', subtitle: 'SUB-BY-NAME' } } },
+    } as any;
+    const viaName = translatePage(page as any, nameBundle, { locale: 'en' });
+    expect(viaName.regions[0].components[0].properties)
+      .toEqual({ title: 'BY-NAME', subtitle: 'SUB-BY-NAME' });
+    // ...and it stops at region level: the nested header keeps its literal.
+    expect(viaName.regions[1].components[0].properties.children[0].properties.title)
+      .toEqual('Inner header');
+
+    // Half four — a nested `page:header` is still reached, by the id route.
+    const nestedBundle = {
+      en: {
+        pages: {
+          header_route_page: { title: 'BY-NAME', components: { inner_header: { title: 'ID::inner' } } },
+        },
+      },
+    } as any;
+    const viaNested = translatePage(page as any, nestedBundle, { locale: 'en' });
+    expect(viaNested.regions[1].components[0].properties.children[0].properties.title)
+      .toEqual('ID::inner');
+    // The extractor offers that nested id, which is the other half of "stays
+    // id-only" — the two sides agree about it as much as about the region one.
+    expect(componentRows(page).filter((r) => r.key === 'inner_header.title'))
+      .toEqual([{ key: 'inner_header.title', value: 'Inner header' }]);
+
+    // Half five — the card's Leg A shape 3, inverted. Both routes present:
+    // BEFORE the ruling the id route won here ("ZH-by-ID"); the page-name
+    // route is canonical now, so the components key is inert on this component
+    // and the bundle that overrode a header title through it falls back.
+    const bothBundle = {
+      en: {
+        pages: {
+          header_route_page: {
+            title: 'BY-NAME',
+            subtitle: 'SUB-BY-NAME',
+            components: { home_header: { title: 'BY-ID' } },
+          },
+        },
+      },
+    } as any;
+    expect(translatePage(page as any, bothBundle, { locale: 'en' }).regions[0].components[0].properties)
+      .toEqual({ title: 'BY-NAME', subtitle: 'SUB-BY-NAME' });
+  });
+
   it('carries the whole shared key list down into nesting, label either/or included', () => {
     const rows = componentRows(walkParityPage());
     // `label` authored at the component's top level, the same either/or
@@ -414,7 +548,10 @@ describe('i18n-extract ↔ translatePage walk parity (#13109)', () => {
       .toEqual([{ key: 'twice.title', value: 'First nested wins' }]);
     // A region-level `page:header` emits nothing here, but its id still BLOCKS
     // a nested namesake — the resolver counts it as region-level, so offering
-    // the nested one would be a key the resolver ignores.
+    // the nested one would be a key the resolver ignores. The ruling changed
+    // what the resolver READS for that id, not who OWNS it: the arbitration is
+    // a property of the document and both consumers still decide it the same
+    // way, which is why this half is unchanged.
     expect(rows.filter((r) => r.key.startsWith('hdr_id.'))).toEqual([]);
 
     // And the resolver agrees about which component the entry lands on.
@@ -432,7 +569,10 @@ describe('i18n-extract ↔ translatePage walk parity (#13109)', () => {
     const translated = translatePage(page as any, bundle, { locale: 'en' });
     const region = translated.regions[0].components;
     expect(region[0].properties.title).toEqual('S');
-    expect(region[1].properties.title).toEqual('H');
+    // `hdr_id` is the region-level `page:header`: the bundle's `H` under
+    // `components.hdr_id.title` is NOT read, and this page has no
+    // `pages.walk_collision_page.title` either, so the authored literal stands.
+    expect(region[1].properties.title).toEqual('Header holds this id');
     const nested = region[2].properties.children;
     expect(nested.map((c: any) => c.properties.title)).toEqual([
       'Nested namesake loses',

packages/spec/src/system/i18n-resolver.test.ts

@@ -1368,7 +1368,20 @@ describe('translatePage', () => {
       expect(byId(out, 'ai_briefing').properties.description).toBe('Open the assistant panel.');
     });
 
-    it('lets the id-addressed route win over the page-name route on a header that has an id', () => {
+    // Ruled 2026-09-06 (maintainer, verbatim 「同意」, decision batch #58,
+    // option 1): "The page-name route is canonical for a region-level
+    // `page:header`. `translatePage` stops reading the id route
+    // (`pages.PAGE.components.HEADERID.*`) for a `page:header` at region
+    // level; a `page:header` nested inside a container stays id-only, as its
+    // doc already says. One component, one address — `title` and `subtitle`
+    // now follow the same rule."
+    //
+    // This test previously asserted the OPPOSITE (`title` resolving to
+    // `快速新建`, the id route beating the page-name one). It is inverted, not
+    // deleted, because the inversion IS the behaviour change the ruling
+    // records: the id route was live for this component and preferred, and a
+    // bundle that used it now falls back to the page-name key.
+    it('reads a region-level `page:header` by page name only, id or no id (batch #58)', () => {
       const doc = {
         name: 'sales_home_page',
         regions: [{
@@ -1384,10 +1397,15 @@ describe('translatePage', () => {
         }],
       };
       const out = translatePage(doc, homeBundle, { locale: 'zh-CN' });
-      // `components.quick_create.title` is more specific than `pages.<name>.label`.
-      expect(out.regions[0].components[0].properties.title).toBe('快速新建');
-      // The page-name route still supplies what the id route did not.
+      // `components.quick_create.title` (`快速新建`) is NOT read here — the
+      // page-name route is, falling back to `pages.<name>.label` for `title`.
+      expect(out.regions[0].components[0].properties.title).toBe('销售看板');
       expect(out.regions[0].components[0].properties.subtitle).toBe('欢迎回来');
+      // Control: the very same bundle entry still reaches the component that
+      // actually owns it, so the assertion above is about the header's route
+      // and not about a bundle that stopped resolving.
+      expect(byId(translatePage(homePage(), homeBundle, { locale: 'zh-CN' }), 'quick_create')
+        .properties.title).toBe('快速新建');
     });
 
     it('does not mutate the input page', () => {

packages/spec/src/system/i18n-resolver.ts

@@ -1663,12 +1663,25 @@ export function walkAddressedPageComponents(
  * `pages.<name>.label` so translators need not repeat a string that is normally
  * identical to the page's nav label.
  *
+ * **One component, one address.** A REGION-LEVEL `page:header` is addressed by
+ * page name and by nothing else: the id route
+ * (`pages.<name>.components.<id>.*`) is NOT read for it, even when it carries
+ * an id (ruled 2026-09-06, decision batch #58 — the page-name route is
+ * canonical). It used to be read there and to WIN, which put the header's
+ * `title` under two addresses while its `subtitle` — not in
+ * {@link PAGE_COMPONENT_COPY_KEYS} — only ever had one; the ruling makes the
+ * two keys of one component follow the same rule. It is also the half of the
+ * failure pair {@link walkAddressedPageComponents} exists to prevent that was
+ * still open: the CLI extractor deliberately offers nothing under
+ * `components.<id>` for this component, so every key read here was a key no
+ * tooling ever offered, counted or reported.
+ *
  * Every OTHER component is addressed by its own `id` through
  * `pages.<name>.components.<id>` (#6080), which overlays that component's
  * `properties` — the page half of what `dashboards.<name>.widgets.<id>` has
- * always given dashboards. Because the id route is the more specific of the
- * two, it wins wherever both could apply (a `page:header` that does carry an
- * id).
+ * always given dashboards. That includes a `page:header` NESTED in a
+ * container, which the page-name route does not reach (below) and which is
+ * therefore id-only.
  *
  * Components nested in a container's declared `properties.children` array are
  * visited too, recursively (#12961, ruled 2026-08-29). This REVERSES the
@@ -1740,8 +1753,24 @@ export function translatePage<T extends PageLike>(
     // within one call `lookupPageComponentCopy` is a pure function of the id
     // (bundle, page name and options are fixed), so the walk's claim-on-first-
     // sighting selects the same component a claim-on-resolved-lookup would.
+    //
+    // The one component this route does NOT serve is a REGION-LEVEL
+    // `page:header`: its copy is addressed by page name below, and reading
+    // `components.<id>` for it too would give one string two addresses. The
+    // condition is written to MIRROR the extractor's emission exception in
+    // `collectExpectedEntries` (`packages/cli`) — same shape, opposite verb —
+    // so the pair the shared walk exists to prevent cannot reopen from this
+    // side. `nested` keeps a `page:header` inside a container on the id route,
+    // which is the only route that reaches it.
+    //
+    // The walk's `addressed` arbitration is deliberately NOT touched: a
+    // region-level `page:header`'s id still CLAIMS its bundle entry and still
+    // blocks a nested namesake. Which component owns an id is a property of
+    // the document, decided identically for every consumer of the walk; only
+    // whether this consumer READS the entry changes here, and the extractor
+    // blocks the namesake the same way.
     let copy: Partial<Record<PageComponentCopyKey, string>> | undefined;
-    if (addressed) {
+    if (addressed && (nested || component.type !== PAGE_HEADER_COMPONENT)) {
       copy = lookupPageComponentCopy(bundle, name, id as string, opts);
     }
 
@@ -1774,9 +1803,11 @@ export function translatePage<T extends PageLike>(
       ...next,
       properties: {
         ...next.properties,
-        // The id-addressed copy above is more specific — do not overwrite what
-        // it already resolved for this header.
-        ...(headerTitle !== undefined && copy?.title === undefined ? { title: headerTitle } : {}),
+        // No `copy?.title` guard: the id route is not read for a region-level
+        // `page:header` at all, so there is nothing here to defer to. A guard
+        // that can never fire is a phantom check — it would read as "the id
+        // route still wins sometimes", which is exactly what the ruling ended.
+        ...(headerTitle !== undefined ? { title: headerTitle } : {}),
         ...(headerSubtitle !== undefined ? { subtitle: headerSubtitle } : {}),
       },
     };

packages/spec/src/system/translation.zod.ts

@@ -835,6 +835,16 @@ const translationDataShape = () => ({
    * because `page:header` instances carry no stable `id`; the page name is the
    * only addressable identifier for them. Every other component does have one,
    * which is what `components` addresses — see its own note.
+   *
+   * **One component, one address.** For a REGION-LEVEL `page:header` the two
+   * keys above are the ONLY route, even when the component happens to carry an
+   * `id`: `translatePage` does not read `components.<id>` for it (ruled
+   * 2026-09-06, decision batch #58 — the page-name route is canonical). Before
+   * that ruling the id route was read here and WON, so a bundle could address
+   * one header `title` two ways while `subtitle` — excluded from `components`
+   * for exactly this reason, see its note below — only ever had one. A
+   * `page:header` NESTED inside a container is a different component: the
+   * page-name route does not reach it, so it stays id-only.
    */
   pages: z.record(z.string(), strictObject({
     surface: 'this page translation',
@@ -868,7 +878,7 @@ const translationDataShape = () => ({
      *
      * | key | declared by |
      * |:---|:---|
-     * | `title` | `page:card`, `record:related_list` (and `page:header`, see below) |
+     * | `title` | `page:card`, `record:related_list` (and a NESTED `page:header` — a region-level one is page-name-addressed, see the `subtitle` note below) |
      * | `label` | `page:tabs`, `page:accordion`, `record:details`, `record:related_list`, `record:path`, `element:button`, `element:record_picker`, `element:text_input` |
      * | `description` | `element:text_input` |
      * | `placeholder` | `element:record_picker`, `element:text_input` |
@@ -896,7 +906,11 @@ const translationDataShape = () => ({
      * - **`subtitle` is not here** — `page:header` is its only declarer, and
      *   that component is addressed by page name above. Declaring it in both
      *   places would give one string two spellings, which is how the
-     *   dashboards/pages asymmetry started.
+     *   dashboards/pages asymmetry started. The 2026-09-06 ruling settled the
+     *   same question for its sibling `title` in the same direction: a
+     *   region-level `page:header` is read by page name only, so the component
+     *   now has ONE address for both of its keys rather than two for one of
+     *   them.
      * - **`content` is not here** — `element:text`'s one authored string is
      *   declared `content: I18nLabelSchema` (`ui/component.zod.ts`), so it is
      *   localizable at its own authoring site, and adding it to this face would