diff --git a/.changeset/25712-sdui-parser-one-body.md b/.changeset/25712-sdui-parser-one-body.md
new file mode 100644
index 00000000000..18a7d5f1ccb
--- /dev/null
+++ b/.changeset/25712-sdui-parser-one-body.md
@@ -0,0 +1,37 @@
+---
+'@objectstack/sdui-parser': patch
+---
+
+feat(sdui-parser)!: one parser body: the renderer copy's additions join `@objectstack/sdui-parser` (#25712)
+
+Clause-②: yes (narrowing: `validateTree` now also judges the nodes held in a manifest entry's declared `slots`, so a caller whose manifest carries `slots` gets diagnostics on slot-held nodes it did not get before)
+Metadata-protocol: none
+
+Two copies of this parser existed: this package, which the save gate runs, and `@object-ui/sdui-parser`, which the renderer runs. `check:sdui-lockstep` held them to one grammar and one code set, and they drifted everywhere else. This change makes this package the one body. The renderer moves onto it and the second copy is deleted in follow-up changes under the same card.
+
+**Added (from the renderer's copy).**
+
+- Node-slot validation (objectui#11170). `ManifestComponent.slots` lists the positions besides `children` where a renderer reads nodes, such as `trigger`, `items[].content` and `regions[].components`. `validateTree` descends each one the way it descends `children`. `manifestFromConfigs` gains a `slotsFor` option that writes the list, and a manifest built without it carries none, so the walk follows `children` alone.
+- The retired `body` child-list key (objectui#6771). Before, `body` drew the bare `unknown-prop`. Now the message names `children`. A `body` child list under a component that takes no children draws `not-a-container`, the code the `children` spelling draws. Both remain warnings. Exported as `checkRetiredBodyDialect` and `RETIRED_CHILD_LIST_KEY`.
+- html-tier provenance (objectui#4000). `parseJsx` stamps every element it builds with an enumerable symbol-keyed marker, `Symbol.for('@object-ui/sdui-parser.html-tier-node')`. `JSON.stringify` and `Object.keys` do not see it. Exported as `HTML_TIER_NODE`, `isHtmlTierNode` and `markHtmlTierNode`. The registry key keeps its original package name on purpose, so a node either copy stamped reads the same.
+- More exports:
+  - `acceptsChildren`, `CHILD_LIST_KEY`, `SDUI_BASE_PROPS`, `SduiBaseProp` and `SduiBasePropScope`;
+  - `assertFullyLoaded`, the manifest generators' guard against lazy stubs, with `RegistryConfigLike.lazy`;
+  - `NodeSlotDeclarationLike`.
+- The generated `.d.ts` header gains `/* eslint-disable */` and names this package.
+
+**Renamed, with the old names kept.** `ParsedSchemaNode` is the parsed node and `ManifestValidationResult` is `validateTree`'s result. These are the names the renderer's copy took so it would not collide with `@object-ui/types`' `SchemaNode` or the spec's `ValidationResult` (objectui#6349, objectui#3161). `SchemaNode` and `ValidationResult` stay exported as `@deprecated` aliases of them, so nothing exported is removed.
+
+**Unchanged.**
+
+- Every `type-mismatch` and `member-type-mismatch` is still an `error`. The renderer's copy graded them `error` only beside an `enum` arm; this package's rule is the one kept.
+- `unconsumed-widget-option` is still emitted as an inline literal.
+- The grammar, the 25 diagnostic codes and the containment predicate.
+
+**BREAKING** (a narrowing of `validateTree` for a manifest that carries `slots`), shipped as `patch` because no metadata protocol kind moves. The save gate's verdicts do not move, and that was measured: the manifest that `objectstack validate`, `build`, `lint` and `serve` read is the tracked `sdui.manifest.json`, which `@objectstack/console` ships. It carries `slots` on 0 of its 106 entries, because its generator calls `manifestFromConfigs` without `slotsFor`. So no save that was accepted before is refused now. The walk has work only for a caller that builds its manifest with `slotsFor`, and today that is the renderer, whose own copy already walks the slots.
+
+Migration, for a TypeScript caller: none is required. To move off the deprecated names, change `SchemaNode` to `ParsedSchemaNode` and `ValidationResult` to `ManifestValidationResult`.
+
+`body-dialect.ts` and `provenance.ts` moved in from the MIT-licensed `@object-ui/sdui-parser` and keep that licence. Each carries the notice, and the package now ships `LICENSE-MIT`.
+
+<!-- adr-0087: not-required (no-migration-prescription) No metadata moves: no spec key, authorable spelling, object definition, stored row or stored shape is added, removed, renamed or re-shaped, so there is nothing for `objectstack migrate meta` to rewrite. What narrows is `validateTree`, a function of this library, for a manifest that carries the new `slots` key: nodes held in those positions are now judged. No manifest the save gate reads carries that key (the tracked `sdui.manifest.json`: 0 of 106 entries), so no stored or authored page changes verdict there. A caller who builds a slotted manifest gets diagnostics on slot-held nodes, and the repair is the page author's per diagnostic, which no ledger entry can derive. The other categories are closed on facts: the package publishes (not unpublished); no ADR-0087 id is named or touched (not registered or already-registered); and nothing exported is removed or narrowed, since the two renamed types stay exported as deprecated aliases (not runtime-interface-only, type-surface-only or runtime-export-retired). -->
diff --git a/packages/sdui-parser/LICENSE-MIT b/packages/sdui-parser/LICENSE-MIT
new file mode 100644
index 00000000000..cf2ca28574c
--- /dev/null
+++ b/packages/sdui-parser/LICENSE-MIT
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ObjectQL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/packages/sdui-parser/package.json b/packages/sdui-parser/package.json
index 500a20eb225..6f65a693467 100644
--- a/packages/sdui-parser/package.json
+++ b/packages/sdui-parser/package.json
@@ -49,7 +49,8 @@
   "files": [
     "dist",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "LICENSE-MIT"
   ],
   "engines": {
     "node": ">=22.0.0"
diff --git a/packages/sdui-parser/src/__tests__/base-props-bind-hidden-11008.test.ts b/packages/sdui-parser/src/__tests__/base-props-bind-hidden-11008.test.ts
new file mode 100644
index 00000000000..eedcfa8cf08
--- /dev/null
+++ b/packages/sdui-parser/src/__tests__/base-props-bind-hidden-11008.test.ts
@@ -0,0 +1,88 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE-MIT file beside this package's manifest.
+ */
+
+/**
+ * `bind` and `hidden` are base props of the tier (objectui#11008).
+ *
+ * `BaseSchema` (`@object-ui/types`) declares both for every node, and no
+ * registration declares either as an input. Before they joined `BASE_PROPS`,
+ * the undeclared-key branch answered every authored one with `unknown-prop`
+ * ("has no prop"), including on the nodes that honour it: `SchemaRenderer`
+ * reads `hidden` for every node, and every `useDataScope` renderer reads
+ * `bind`. This file pins the TIER's reading of a manifest; the live-registry
+ * half — `list`, `tree-view` and `data-table` — is
+ * `ui/packages/components/src/renderers/__tests__/bind-base-prop-parser-tier-11008.test.tsx`.
+ *
+ * Three facts, kept apart because each one fails differently:
+ *
+ *   - both keys draw nothing, in every value shape `BaseSchema` admits for
+ *     them — the fix;
+ *   - a near-miss spelling (`bindTo`, `hide`) on the SAME node still draws
+ *     `unknown-prop` naming it — the lit control. Without it, "draws nothing"
+ *     would also pass against a tier that stopped warning on undeclared keys;
+ *   - a registration that DECLARES `placeholder` keeps its `type-mismatch`.
+ *     `placeholder` is a `BaseSchema` member too, and it was left out of the
+ *     `every-node` members because they skip the declared-input lookup. It
+ *     joined later as a `where-undeclared` member (objectui#11044), which a
+ *     declared input outranks: this row goes red if it is ever made an
+ *     `every-node` member the way `bind` and `hidden` were.
+ */
+import { describe, expect, it } from 'vitest';
+import { manifestFromConfigs, validateTree } from '../index.js';
+import type { Diagnostic, Manifest, SchemaElement } from '../types.js';
+
+const manifest: Manifest = manifestFromConfigs([
+  // a leaf that declares neither key, as no live registration does
+  { type: 'leaf', namespace: 'ui', inputs: [{ name: 'content', type: 'string' }] },
+  // the input-family shape: `placeholder` declared as a typed input
+  { type: 'field', namespace: 'ui', inputs: [{ name: 'placeholder', type: 'string' }] },
+] as unknown as Parameters<typeof manifestFromConfigs>[0]);
+
+const diagnose = (node: unknown): Diagnostic[] =>
+  validateTree(node as SchemaElement, manifest).diagnostics;
+
+const LEAF = { type: 'leaf', content: 'x' };
+
+/** Every value shape `BaseSchema` declares for the two keys. */
+const BASE_VALUES: Record<'bind' | 'hidden', unknown[]> = {
+  bind: ['users', 'app.settings.users'],
+  hidden: [true, false, '${data.role !== "admin"}', { dialect: 'cel', source: "record.status == 'draft'" }],
+};
+
+describe('objectui#11008 — `bind` and `hidden` are base props of the parser tier', () => {
+  it('the control node draws nothing', () => {
+    expect(diagnose(LEAF)).toEqual([]);
+  });
+
+  it.each(Object.keys(BASE_VALUES) as Array<keyof typeof BASE_VALUES>)(
+    '`%s` draws no diagnostic, in every value shape BaseSchema admits',
+    (key) => {
+      const drew = BASE_VALUES[key]
+        .map((value) => [value, diagnose({ ...LEAF, [key]: value })] as const)
+        .filter(([, found]) => found.length > 0)
+        .map(([value, found]) => `${JSON.stringify(value)} → ${JSON.stringify(found.map((d) => d.code))}`);
+      expect(drew).toEqual([]);
+    },
+  );
+
+  it.each([
+    ['bindTo', 'users'],
+    ['hide', true],
+  ] as const)('lit control: the near-miss `%s` still draws one `unknown-prop` naming it', (key, value) => {
+    const found = diagnose({ ...LEAF, [key]: value });
+    expect(found.map((d) => d.code)).toEqual(['unknown-prop']);
+    expect(found[0]!.message).toContain(`"${key}"`);
+  });
+
+  it('a registration that declares `placeholder` keeps its type check — why `placeholder` is not `every-node`', () => {
+    expect(diagnose({ type: 'field', placeholder: 'Search…' })).toEqual([]);
+    const found = diagnose({ type: 'field', placeholder: 42 });
+    expect(found.map((d) => d.code)).toEqual(['type-mismatch']);
+    expect(found[0]!.message).toContain('"placeholder"');
+  });
+});
diff --git a/packages/sdui-parser/src/__tests__/base-props-one-list-11044.test.ts b/packages/sdui-parser/src/__tests__/base-props-one-list-11044.test.ts
new file mode 100644
index 00000000000..8f8360e7410
--- /dev/null
+++ b/packages/sdui-parser/src/__tests__/base-props-one-list-11044.test.ts
@@ -0,0 +1,265 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE-MIT file beside this package's manifest.
+ */
+
+/**
+ * The base props are ONE list, and both of its readers read it (objectui#11044).
+ *
+ * `validateTree`'s `unknown-prop` branch and `generateDts`'s `SduiBaseProps`
+ * used to keep separate hand-written copies of the base-prop list. They
+ * drifted: after objectui#11008 the validator accepted `bind` and `hidden` on
+ * every node, and the generated JSX types still refused both
+ * (`TS2322 … Property bind does not exist on type ListProps`). Both now read
+ * `SDUI_BASE_PROPS`. This file pins the tier's reading of a manifest; the
+ * live-registry half is
+ * `ui/packages/components/src/renderers/__tests__/base-props-one-list-11044.test.tsx`.
+ *
+ * Four facts, kept apart because each fails differently:
+ *
+ *   - ONE LIST: the generated `SduiBaseProps` block is exactly the list's
+ *     attribute entries, and every entry is accepted on a node that declares
+ *     nothing, while a near-miss spelling still draws `unknown-prop` (the lit
+ *     control — without it, "draws nothing" would also pass against a tier
+ *     that stopped warning on undeclared keys);
+ *   - MEMBER 1: `visibleWhen`, `hiddenOn` and `testId` are accepted on every
+ *     node, as `bind` and `hidden` are;
+ *   - MEMBER 2 (the triage ruling): a `'where-undeclared'` member is a base
+ *     prop only where the type declares no input of that name. Where one does,
+ *     the declared input wins, `type-mismatch` included;
+ *   - MEMBER 3: the generated `.d.ts`, compiled by `tsc`, accepts the base
+ *     props on a type that declares none of them, refuses a near-miss, and
+ *     lets a declared input's type win without a TS2430 conflict — for an
+ *     `'every-node'` member too (objectui#11075): `notice` declares `visible`
+ *     wider than the base `boolean`, as `record:alert` does in the live
+ *     registry. The real public manifest's half is
+ *     `ui/apps/console/src/__tests__/sdui-intrinsics-compile-11075.test.ts`.
+ */
+import { describe, expect, it } from 'vitest';
+import ts from 'typescript';
+import { generateDts, manifestFromConfigs, SDUI_BASE_PROPS, validateTree } from '../index.js';
+import type { Diagnostic, SchemaElement } from '../types.js';
+
+/**
+ * `leaf` declares none of the base props, as no live registration declares
+ * any `'every-node'` member added here. `field` declares every
+ * `'where-undeclared'` member as a typed input — the input-family shape — and
+ * two of them with a type the base one does not admit (`label` takes any
+ * object, `data` only an array). `notice` declares three `'every-node'`
+ * members (objectui#11075): `visible` with the three arms `record:alert`
+ * declares, which the base `boolean` does not admit, and `disabled` /
+ * `className` with the base type; its `children` input is a slot.
+ */
+const manifest = manifestFromConfigs([
+  { type: 'leaf', namespace: 'ui', inputs: [{ name: 'content', type: 'string' }] },
+  {
+    type: 'field',
+    namespace: 'ui',
+    inputs: [
+      { name: 'name', type: 'string' },
+      { name: 'label', type: ['string', 'object'] },
+      { name: 'description', type: 'string' },
+      { name: 'placeholder', type: 'string' },
+      { name: 'data', type: 'array' },
+      { name: 'ariaLabel', type: 'string' },
+    ],
+  },
+  {
+    type: 'list',
+    namespace: 'ui',
+    inputs: [
+      { name: 'title', type: 'string' },
+      { name: 'items', type: 'array' },
+    ],
+  },
+  {
+    type: 'notice',
+    namespace: 'ui',
+    inputs: [
+      { name: 'message', type: 'string' },
+      { name: 'visible', type: ['boolean', 'string', 'object'] },
+      { name: 'disabled', type: 'boolean' },
+      { name: 'className', type: 'string' },
+      { name: 'children', type: 'slot' },
+    ],
+  },
+] as unknown as Parameters<typeof manifestFromConfigs>[0]);
+
+const diagnose = (node: unknown): Diagnostic[] =>
+  validateTree(node as SchemaElement, manifest).diagnostics;
+
+const LEAF = { type: 'leaf', content: 'x' };
+
+/** A value of the kind `BaseSchema` declares for each member. */
+const WELL_TYPED: Record<string, unknown> = {
+  id: 'n1',
+  className: 'p-2',
+  style: { padding: 4 },
+  visible: true,
+  visibleWhen: "data.role == 'admin'",
+  visibleOn: "data.role == 'admin'",
+  hidden: true,
+  hiddenOn: "data.role != 'admin'",
+  disabled: false,
+  disabledOn: 'data.locked',
+  bind: 'users',
+  testId: 'users-list',
+  children: [],
+  name: 'email',
+  label: 'Email',
+  description: 'Where we write',
+  placeholder: 'you@example.com',
+  data: [{ id: 1 }],
+  ariaLabel: 'Email address',
+};
+
+const WHERE_UNDECLARED = SDUI_BASE_PROPS.filter((p) => p.scope === 'where-undeclared').map((p) => p.name);
+
+describe('objectui#11044 — the base props are one list, read by the validator and the codegen', () => {
+  it('the list names each key once, and every attribute entry has a value to test it with', () => {
+    const names = SDUI_BASE_PROPS.map((p) => p.name);
+    expect(new Set(names).size).toBe(names.length);
+    // `type` is the one entry that is no attribute: the tag name carries it.
+    expect(SDUI_BASE_PROPS.filter((p) => p.tsType === null).map((p) => p.name)).toEqual(['type']);
+    expect(Object.keys(WELL_TYPED).sort()).toEqual(names.filter((n) => n !== 'type').sort());
+  });
+
+  it('the generated `SduiBaseProps` is exactly the list, in order, with each entry’s type', () => {
+    const block = generateDts(manifest).match(/export interface SduiBaseProps \{\n([\s\S]*?)\n\}\n/);
+    expect(block, 'no SduiBaseProps interface in the generated d.ts').toBeTruthy();
+    expect(block![1].split('\n')).toEqual(
+      SDUI_BASE_PROPS.filter((p) => p.tsType !== null).map((p) => `  ${p.name}?: ${p.tsType};`),
+    );
+  });
+
+  it('the control node draws nothing', () => {
+    expect(diagnose(LEAF)).toEqual([]);
+  });
+
+  it.each(Object.keys(WELL_TYPED))('`%s` draws nothing on a node that declares no input of that name', (key) => {
+    expect(diagnose({ ...LEAF, [key]: WELL_TYPED[key] })).toEqual([]);
+  });
+
+  it.each([
+    ['testid', 'n1'],
+    ['visibleIf', 'data.x'],
+    ['hiddenWhen', 'data.x'],
+    ['aria-label', 'x'],
+  ] as const)('lit control: the near-miss `%s` still draws one `unknown-prop` naming it', (key, value) => {
+    const found = diagnose({ ...LEAF, [key]: value });
+    expect(found.map((d) => d.code)).toEqual(['unknown-prop']);
+    expect(found[0]!.message).toContain(`"${key}"`);
+  });
+});
+
+describe('objectui#11044 member 1 — `visibleWhen`, `hiddenOn` and `testId` are base props of every node', () => {
+  it.each(['visibleWhen', 'hiddenOn', 'testId'])('`%s` is an `every-node` member', (key) => {
+    expect(SDUI_BASE_PROPS.find((p) => p.name === key)?.scope).toBe('every-node');
+    expect(diagnose({ ...LEAF, [key]: WELL_TYPED[key] })).toEqual([]);
+  });
+});
+
+describe('objectui#11044 member 2 — a declared input outranks a `where-undeclared` base prop', () => {
+  it('the six subset-declared `BaseSchema` members are the `where-undeclared` ones', () => {
+    expect([...WHERE_UNDECLARED].sort()).toEqual(['ariaLabel', 'data', 'description', 'label', 'name', 'placeholder']);
+  });
+
+  it.each(WHERE_UNDECLARED)('`%s`: where the type declares it, a wrong-typed value keeps its `type-mismatch`', (key) => {
+    expect(diagnose({ type: 'field', [key]: WELL_TYPED[key] })).toEqual([]);
+    const found = diagnose({ type: 'field', [key]: 424242 });
+    expect(found.map((d) => d.code)).toEqual(['type-mismatch']);
+    expect(found[0]!.message).toContain(`"${key}"`);
+  });
+
+  it.each(WHERE_UNDECLARED)('`%s`: where the type does not declare it, it is a base prop and draws nothing', (key) => {
+    expect(diagnose({ ...LEAF, [key]: WELL_TYPED[key] })).toEqual([]);
+  });
+});
+
+/** One statement per line: diagnostics are mapped back to cases BY LINE. */
+const TSX_CASES: ReadonlyArray<{ what: string; code: string; rejected: boolean }> = [
+  { what: 'control: declared inputs', rejected: false, code: `export const c0 = <list title="Users" items={['Ada']} />;` },
+  { what: '`bind` (objectui#11008)', rejected: false, code: `export const c1 = <list bind="users" />;` },
+  { what: '`hidden` (objectui#11008)', rejected: false, code: `export const c2 = <list hidden={true} />;` },
+  { what: '`visibleWhen`', rejected: false, code: `export const c3 = <list visibleWhen="data.role == 'admin'" />;` },
+  { what: '`hiddenOn`', rejected: false, code: `export const c4 = <list hiddenOn="data.archived" />;` },
+  { what: '`testId`', rejected: false, code: `export const c5 = <list testId="users-list" />;` },
+  { what: 'an undeclared `label`', rejected: false, code: `export const c6 = <list label="Users" />;` },
+  { what: 'lit control: a near-miss', rejected: true, code: `export const c7 = <list bindTo="users" />;` },
+  { what: 'a declared `data` array', rejected: false, code: `export const c8 = <field data={['a']} />;` },
+  { what: 'the declared `data` type wins over the base one', rejected: true, code: `export const c9 = <field data={{ a: 1 }} />;` },
+  { what: 'the base `data` type where undeclared', rejected: false, code: `export const c10 = <list data={{ a: 1 }} />;` },
+  { what: 'objectui#11075: a declared `visible` takes a string', rejected: false, code: `export const c11 = <notice visible="data.open" />;` },
+  { what: 'objectui#11075: a declared `visible` takes an envelope', rejected: false, code: `export const c12 = <notice visible={{ dialect: 'cel', source: 'data.open' }} />;` },
+  { what: 'objectui#11075: a declared `visible` still judges the value', rejected: true, code: `export const c13 = <notice visible={1} />;` },
+  { what: 'objectui#11075 control: the base `visible` stays `boolean` where undeclared', rejected: true, code: `export const c14 = <list visible="data.open" />;` },
+  { what: 'objectui#11075: a declared `slot` keeps the base `children`', rejected: false, code: `export const c15 = <notice className="p-2" disabled={false}><list /></notice>;` },
+];
+
+/** `tsc` over the generated `.d.ts` plus one page, in memory. */
+function typeCheck(): { dts: readonly ts.Diagnostic[]; erroredLines: ReadonlySet<number> } {
+  const files: Record<string, string> = {
+    '/sdui-probe/sdui-intrinsics.d.ts': generateDts(manifest),
+    '/sdui-probe/page.tsx': `${TSX_CASES.map((c) => c.code).join('\n')}\n`,
+  };
+  const options: ts.CompilerOptions = {
+    strict: true,
+    noEmit: true,
+    jsx: ts.JsxEmit.Preserve,
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    types: [],
+  };
+  const host = ts.createCompilerHost(options);
+  const getSourceFile = host.getSourceFile.bind(host);
+  host.getSourceFile = (fileName, languageVersion, ...rest) =>
+    fileName in files
+      ? ts.createSourceFile(fileName, files[fileName]!, languageVersion, true)
+      : getSourceFile(fileName, languageVersion, ...rest);
+  const fileExists = host.fileExists.bind(host);
+  host.fileExists = (fileName) => fileName in files || fileExists(fileName);
+  const readFile = host.readFile.bind(host);
+  host.readFile = (fileName) => files[fileName] ?? readFile(fileName);
+  const program = ts.createProgram(Object.keys(files), options, host);
+  const all = ts.getPreEmitDiagnostics(program);
+  const page = all.filter((d) => d.file?.fileName === '/sdui-probe/page.tsx');
+  return {
+    dts: all.filter((d) => d.file?.fileName !== '/sdui-probe/page.tsx'),
+    erroredLines: new Set(
+      page.map((d) => d.file!.getLineAndCharacterOfPosition(d.start ?? 0).line),
+    ),
+  };
+}
+
+describe('objectui#11044 member 3 — the generated JSX types read the same list', () => {
+  const { dts, erroredLines } = typeCheck();
+
+  it('the generated `.d.ts` itself compiles — a declared type the base one does not admit is no TS2430', () => {
+    expect(dts.map((d) => ts.flattenDiagnosticMessageText(d.messageText, '\n'))).toEqual([]);
+    expect(generateDts(manifest)).toContain(
+      'export interface FieldProps extends Omit<SduiBaseProps, "name" | "label" | "description" | "placeholder" | "data" | "ariaLabel"> {',
+    );
+    expect(generateDts(manifest)).toContain('export interface ListProps extends SduiBaseProps {');
+  });
+
+  it('objectui#11075: every declared `every-node` attribute is `Omit`ted, in declaration order, and the base is unmoved', () => {
+    const dts = generateDts(manifest);
+    // `children` is declared too, but as a slot: no attribute, so no `Omit`.
+    expect(dts).toContain('export interface NoticeProps extends Omit<SduiBaseProps, "visible" | "disabled" | "className"> {');
+    expect(dts).toContain('  visible?: boolean | string | Record<string, unknown>;');
+    const base = dts.match(/export interface SduiBaseProps \{\n([\s\S]*?)\n\}\n/)?.[1].split('\n') ?? [];
+    expect(base).toContain('  visible?: boolean;');
+    expect(base).toContain('  children?: unknown;');
+  });
+
+  it.each(TSX_CASES.map((c, line) => [c.what, c.rejected, line] as const))(
+    '%s — rejected: %s',
+    (_what, rejected, line) => {
+      expect(erroredLines.has(line)).toBe(rejected);
+    },
+  );
+});
diff --git a/packages/sdui-parser/src/__tests__/body-dialect-6771.test.ts b/packages/sdui-parser/src/__tests__/body-dialect-6771.test.ts
new file mode 100644
index 00000000000..79625bdc54d
--- /dev/null
+++ b/packages/sdui-parser/src/__tests__/body-dialect-6771.test.ts
@@ -0,0 +1,131 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE-MIT file beside this package's manifest.
+ */
+
+/**
+ * The tier's half of objectui#6771 — the retired `body` child-list dialect.
+ *
+ * ## Why this file exists at all
+ *
+ * The retirement's acceptance evidence was measured on the BUILT CLI, and that
+ * reading is about the ZOD tier: `objectui validate` parses through
+ * `@object-ui/types`' mirrors, where `body` is an `aliasKeyRefusal`. ⛔ It says
+ * NOTHING about `validateTree`, which is a different tier with a different
+ * vocabulary — it parses a manifest, never a zod schema, and it is the tier the
+ * card was FILED about: the original defect was that `validateTree` answered
+ * `unknown-prop` on `body`, the one spelling a dozen registrations resolved.
+ *
+ * ⇒ a change that moves what this tier says about `body` needs its own pin, or
+ * the card's own subject is the one surface with no coverage.
+ *
+ * ## The two verdicts, and why they are two
+ *
+ * The ruling's step 4 has two clauses: the tier teaches `children` only, and a
+ * `body` child list under a non-container draws the same `not-a-container` the
+ * `children` spelling draws. `./body-dialect.ts` answers both by REPLACING the
+ * prop walk's diagnostic rather than adding to it — two diagnostics for one
+ * mistake is the shape `checkMemberTypes` already refuses (objectui#8067).
+ *
+ * ## ⚠️ What each row must not be allowed to pass on
+ *
+ * Every assertion below names a CODE and asserts the message names `children`.
+ * The code alone is not enough: the pre-retirement tier already answered
+ * `unknown-prop` for `body`, so a row asserting only that code is green in BOTH
+ * worlds and measures nothing. What moved is that the answer now carries the
+ * remedy, which is the whole reason the replacement exists rather than a bare
+ * refusal. And the `children` control beside each row is what keeps "the tier
+ * refuses `body`" a reading rather than "this tier refuses everything".
+ */
+import { describe, expect, it } from 'vitest';
+import { RETIRED_CHILD_LIST_KEY, manifestFromConfigs, validateTree } from '../index.js';
+import type { Diagnostic, Manifest, SchemaElement } from '../types.js';
+
+/**
+ * Two blocks and nothing else: one that accepts children and one that does not.
+ * The containment verdict is keyed on the declared `children` slot input —
+ * ⛔ not on `isContainer`, since objectui#9910 — so those two are the whole
+ * population this rule can distinguish. `box` carries the flag too, as the
+ * layout fact it still is; `acceptsChildren` in `../validate.ts` never reads it.
+ */
+const manifest: Manifest = manifestFromConfigs([
+  { type: 'box', namespace: 'ui', isContainer: true, inputs: [{ name: 'className', type: 'string' }, { name: 'children', type: 'slot' }] },
+  { type: 'badge', namespace: 'ui', inputs: [{ name: 'label', type: 'string' }] },
+  // Declared so the CHILD below resolves: `validateTree` descends `children`,
+  // and an undeclared child draws `unknown-component`, which would make the
+  // silence controls below assert the wrong absence.
+  { type: 'text', namespace: 'ui', inputs: [{ name: 'content', type: 'string' }] },
+  // Declares `body` as its OWN input — the carve-out this rule must respect.
+  { type: 'detail', namespace: 'plugin-detail', inputs: [{ name: 'body', type: 'string' }] },
+] as unknown as Parameters<typeof manifestFromConfigs>[0]);
+
+const CHILD = { type: 'text', content: 'measured' };
+const diagnose = (node: unknown): Diagnostic[] =>
+  validateTree(node as SchemaElement, manifest).diagnostics;
+
+describe('objectui#6771 — the tier answers the retired `body` with its replacement', () => {
+  it('the exported key IS the retired spelling, so the rule and its pin cannot drift', () => {
+    expect(RETIRED_CHILD_LIST_KEY).toBe('body');
+  });
+
+  it('a `body` child list under a NON-container draws `not-a-container` — the ruling clause, verbatim', () => {
+    const found = diagnose({ type: 'badge', body: [CHILD] });
+    expect(found.map((d) => d.code)).toContain('not-a-container');
+    // The SAME code the live spelling draws — that is what "the same
+    // `not-a-container` the `children` spelling draws" means, and a consumer
+    // keying on the code cannot tell the two spellings apart.
+    expect(diagnose({ type: 'badge', children: [CHILD] }).map((d) => d.code)).toContain('not-a-container');
+    // …and only the retired one also names the remedy.
+    expect(found.find((d) => d.code === 'not-a-container')!.message).toContain('"children"');
+  });
+
+  it('ONE diagnostic, not two — the replacement replaces', () => {
+    // ⛔ The failure this guards is the obvious implementation: leave the prop
+    // walk's `unknown-prop` in place and ADD a containment branch that reads
+    // `body`. That author gets two reports for one mistake.
+    const found = diagnose({ type: 'badge', body: [CHILD] });
+    expect(found.filter((d) => d.message.includes('"body"'))).toHaveLength(1);
+  });
+
+  it('a `body` child list under a CONTAINER draws `unknown-prop` naming `children`', () => {
+    const found = diagnose({ type: 'box', body: [CHILD] });
+    const own = found.filter((d) => d.message.includes('"body"'));
+    expect(own).toHaveLength(1);
+    expect(own[0]!.code).toBe('unknown-prop');
+    expect(own[0]!.message).toContain('"children"');
+    // CONTROL — the live spelling under the same block is silent, so the row
+    // above is about the key and not about the block.
+    expect(diagnose({ type: 'box', children: [CHILD] })).toHaveLength(0);
+  });
+
+  it('a SCALAR `body` is a dead key and nothing more — no containment sentence', () => {
+    // The containment wording names a shape; naming it for `body: "hi"` would
+    // describe a child list the author did not write.
+    const found = diagnose({ type: 'badge', body: 'hi' });
+    const own = found.filter((d) => d.message.includes('"body"'));
+    expect(own).toHaveLength(1);
+    expect(own[0]!.code).toBe('unknown-prop');
+    expect(own[0]!.message).toContain('"children"');
+  });
+
+  it('⛔ a component that DECLARES its own `body` input is untouched', () => {
+    // ⚠️ The fixture below is SYNTHETIC — a manifest is an argument to
+    // `validateTree`, so this file can ask what the rule says about any shape.
+    // The real component this carve-out exists for is `record:alert`, the one
+    // registration in the tree that declares an input named `body` (its value is
+    // an inline translation map, not a child list); the extension's own gate
+    // names it, and `sdui-parser` needs no list because it asks inside the
+    // `!input` branch, deliberately: the claim is about a key nobody declares.
+    expect(diagnose({ type: 'detail', body: 'Updated the deal stage.' })).toHaveLength(0);
+  });
+
+  it('the tier still teaches `children` ONLY — `body` never became a base prop', () => {
+    // The option the ruling REFUSED was adding `body` to `BASE_PROPS`, which
+    // would have made it a blessed second spelling forever. If it were there,
+    // every row above would be silent.
+    expect(diagnose({ type: 'box', body: [CHILD] }).length).toBeGreaterThan(0);
+  });
+});
diff --git a/packages/sdui-parser/src/__tests__/containment-declared-slot.test.ts b/packages/sdui-parser/src/__tests__/containment-declared-slot.test.ts
index 8b669f76a15..a6367db3cc0 100644
--- a/packages/sdui-parser/src/__tests__/containment-declared-slot.test.ts
+++ b/packages/sdui-parser/src/__tests__/containment-declared-slot.test.ts
@@ -11,6 +11,8 @@
  * `containment-declared-slot-9910.test.ts`, because the two failure modes are
  * OPPOSITE: a flag-only cell drawing nothing is the fallback silently
  * re-introduced, and a slot-only cell drawing the warning is the defect.
+ * Since #25712 one copy serves both, and the last block carries the cases the
+ * renderer's file pinned beyond the 2×2.
  *
  * The second half uses the REAL served entries: in the tracked
  * `sdui.manifest.json` (regenerated at the console pin, `0bf85eaa`) exactly
@@ -19,9 +21,8 @@
  * package's tests keep reading only this package.
  */
 import { describe, expect, it } from 'vitest';
-import { manifestFromConfigs, validateTree } from '../index.js';
-import { CHILD_LIST_KEY, acceptsChildren } from '../validate.js';
-import type { Manifest, ManifestComponent, SchemaElement } from '../types.js';
+import { CHILD_LIST_KEY, acceptsChildren, manifestFromConfigs, validateTree } from '../index.js';
+import type { Diagnostic, Manifest, ManifestComponent, SchemaElement } from '../types.js';
 
 const CONTAINMENT = 'not-a-container';
 const SLOT = { name: 'children', type: 'slot' } as const;
@@ -284,3 +285,70 @@ describe('#19969 — the five served entries where the flag and the declared inp
     },
   );
 });
+
+describe('objectui#9910 — the base key, the retired spelling, and the layout flag', () => {
+  // The renderer's copy pinned these beside its 2×2, over a manifest whose rows
+  // nest a declared `text` child so nothing draws `unknown-component`.
+  const manifest: Manifest = manifestFromConfigs([
+    // flag, no slot — a layout container that renders `items[].children`, never
+    // `schema.children` (the `page:tabs` shape)
+    { type: 'flag-only', namespace: 'ui', isContainer: true, inputs: [{ name: 'items', type: 'array' }] },
+    // slot, no flag — a label-fallback reader (the `button` / `badge` shape)
+    { type: 'slot-only', namespace: 'ui', inputs: [{ name: 'label', type: 'string' }, SLOT] },
+    // both — a layout container that renders the list (the `flex` shape)
+    { type: 'both', namespace: 'ui', isContainer: true, inputs: [{ name: 'gap', type: 'number' }, SLOT] },
+    // neither — a leaf
+    { type: 'neither', namespace: 'ui', inputs: [{ name: 'content', type: 'string' }] },
+    // the page kinds publish `children` typed `array`, not `slot` — the NAME is
+    // the declaration, so this row must read as accepting children too
+    { type: 'array-typed', namespace: 'ui', inputs: [{ name: 'children', type: 'array', of: 'object' }] },
+    // the child every row nests, declared so it never draws `unknown-component`
+    { type: 'text', namespace: 'ui', inputs: [{ name: 'content', type: 'string' }] },
+  ] as unknown as Parameters<typeof manifestFromConfigs>[0]);
+
+  const CHILD = { type: 'text', content: 'measured' };
+  const codes = (node: unknown): string[] =>
+    validateTree(node as SchemaElement, manifest).diagnostics.map((d: Diagnostic) => d.code);
+  const withChildren = (type: string) => ({ type, children: [CHILD] });
+
+  it('a declared `children` slot is never type-checked or reported as a prop — the key is base', () => {
+    // `children` is in `BASE_PROPS`, so the prop walk skips it before the
+    // declared input is ever consulted: no `unknown-prop`, no `type-mismatch`,
+    // whichever coarse type the declaration carries.
+    for (const type of ['slot-only', 'both', 'array-typed', 'flag-only', 'neither']) {
+      const found = codes(withChildren(type));
+      expect(found.filter((c) => c === 'unknown-prop' || c === 'type-mismatch')).toEqual([]);
+    }
+    // …and the reachability control: the nested child resolved everywhere.
+    for (const type of ['slot-only', 'both', 'array-typed', 'flag-only', 'neither']) {
+      expect(codes(withChildren(type))).not.toContain('unknown-component');
+    }
+  });
+
+  it('the retired `body` spelling follows the SAME predicate', () => {
+    // `checkRetiredBodyDialect` is handed `acceptsChildren(comp)`, so the two
+    // spellings cannot disagree about which components take a list.
+    const under = (type: string) =>
+      validateTree({ type, body: [CHILD] } as unknown as SchemaElement, manifest).diagnostics.filter((d) =>
+        d.message.includes('"body"'),
+      );
+    // slot declared ⇒ the list would be accepted under `children`, so `body`
+    // is answered as a retired key that names the replacement
+    expect(under('slot-only').map((d) => d.code)).toEqual(['unknown-prop']);
+    expect(under('slot-only')[0]!.message).toContain('"children"');
+    // flag only ⇒ no list is accepted here, so `body` draws the containment
+    // sentence — the flag does not rescue the retired spelling either
+    expect(under('flag-only').map((d) => d.code)).toEqual([CONTAINMENT]);
+    expect(under('neither').map((d) => d.code)).toEqual([CONTAINMENT]);
+  });
+
+  it('the manifest still CARRIES `isContainer` for the consumers that read layout containment', () => {
+    // Q2-A keeps the field: `manifestFromConfigs` projects it unchanged, the
+    // react-page scope builder and the public layout ledger read it, and this
+    // tier ignores it. Asserted so a later "clean-up" that drops the projection
+    // is a visible decision rather than a side effect.
+    expect(manifest.components['flag-only']!.isContainer).toBe(true);
+    expect(manifest.components['both']!.isContainer).toBe(true);
+    expect(manifest.components['slot-only']!.isContainer).toBeUndefined();
+  });
+});
diff --git a/packages/sdui-parser/src/__tests__/dashboard-widget-options.test.ts b/packages/sdui-parser/src/__tests__/dashboard-widget-options.test.ts
index 76f3d103f7d..138696a4ebb 100644
--- a/packages/sdui-parser/src/__tests__/dashboard-widget-options.test.ts
+++ b/packages/sdui-parser/src/__tests__/dashboard-widget-options.test.ts
@@ -345,3 +345,29 @@ describe('what draws NOTHING — every accepted key, and every out-of-scope shap
     expect(d.filter((x) => x.code === UNCONSUMED_WIDGET_OPTION)).toEqual([]);
   });
 });
+
+describe('the retired metric sub-caption draws the warning (objectui#11389, ruling C)', () => {
+  // `options.description` was the metric tile's sub-caption, accepted on its
+  // read sites. Both ends retired it (objectstack first, `@objectstack/spec`
+  // 17.7.0; then every reader in `plugin-dashboard`), so it reaches no renderer
+  // and is reported like any other unconsumed key. The verdict before this
+  // change was no diagnostic at all; it is now one warning, never an error.
+  const metric = { id: 'won_revenue', type: 'metric', dataset: 'sales', values: ['revenue'] };
+
+  it.each([
+    ['a plain string', 'Won this quarter'],
+    ['an inline per-locale map', { en: 'Won this quarter', 'zh-CN': '本季度已赢单' }],
+  ])('an authored options.description as %s draws one unconsumed-widget-option warning', (_label, description) => {
+    const found = unconsumed(dash({ ...metric, options: { description } }));
+    expect(found).toHaveLength(1);
+    expect(found[0]!.severity).toBe('warning');
+    expect(found[0]!.code).toBe(UNCONSUMED_WIDGET_OPTION);
+    // The subject is named: the key, and the widget it sits on.
+    expect(found[0]!.message).toContain('options.description');
+    expect(found[0]!.message).toContain('"won_revenue"');
+  });
+
+  it('control: the widget-level `description` (the card-header subtitle) and a declared option draw nothing', () => {
+    expect(unconsumed(dash({ ...metric, description: 'Card header subtitle', options: { limit: 5 } }))).toEqual([]);
+  });
+});
diff --git a/packages/sdui-parser/src/__tests__/deprecated-type-aliases.test.ts b/packages/sdui-parser/src/__tests__/deprecated-type-aliases.test.ts
new file mode 100644
index 00000000000..aedc3ba379f
--- /dev/null
+++ b/packages/sdui-parser/src/__tests__/deprecated-type-aliases.test.ts
@@ -0,0 +1,27 @@
+/**
+ * The two type names this package published before #25712 made the two copies
+ * of this parser one stay importable, as deprecated aliases of the names the
+ * renderer's copy had already moved to (objectui#6349, objectui#3161). The
+ * rename therefore removes nothing exported, which keeps it out of `major`: the
+ * launch-window guard (`scripts/check-changeset-no-major.mjs`) refuses a major.
+ *
+ * Type-level pins: `pnpm typecheck` compiles this file, and a dropped or
+ * re-pointed alias fails it.
+ */
+import { describe, expect, expectTypeOf, it } from 'vitest';
+import { validateTree } from '../index.js';
+import type { ManifestValidationResult, ParsedSchemaNode, SchemaNode, ValidationResult } from '../index.js';
+
+describe('deprecated type aliases (#25712)', () => {
+  it('`SchemaNode` is `ParsedSchemaNode`', () => {
+    expectTypeOf<SchemaNode>().toEqualTypeOf<ParsedSchemaNode>();
+  });
+
+  it('`ValidationResult` is `ManifestValidationResult`, the type `validateTree` returns', () => {
+    const result = validateTree(null, { components: {} });
+    expectTypeOf<ValidationResult>().toEqualTypeOf<ManifestValidationResult>();
+    expectTypeOf(result).toEqualTypeOf<ValidationResult>();
+    // Runtime control: the call the type pin rides on really returns the shape.
+    expect(Object.keys(result).sort()).toEqual(['bindings', 'diagnostics', 'requires']);
+  });
+});
diff --git a/packages/sdui-parser/src/__tests__/input-type-union.test.ts b/packages/sdui-parser/src/__tests__/input-type-union.test.ts
new file mode 100644
index 00000000000..a481800aa18
--- /dev/null
+++ b/packages/sdui-parser/src/__tests__/input-type-union.test.ts
@@ -0,0 +1,233 @@
+/**
+ * ObjectUI — `ManifestInput.type` as a union of arms (objectui#3832)
+ *
+ * The mechanism half of the card; the user-visible half (the five measured
+ * specimens, through the manifest the console really builds) lives in
+ * `ui/apps/console/src/__tests__/component-input-union-specimens.test.ts`.
+ *
+ * Three facts are pinned here, and they are different facts:
+ *
+ *  1. ANY-ARM — a value passes when any declared arm accepts it, and is still
+ *     reported when none does. The second half is the one that can rot silently:
+ *     a `switch (input.type)` handed an array falls into its default branch and
+ *     returns null, so a broken implementation looks exactly like a clean value.
+ *  2. BACKWARD COMPATIBILITY — a single-kind declaration behaves and serializes
+ *     byte-identically to before. This is what makes the change an extension of
+ *     `sdui.manifest.json` rather than a new version of it.
+ *  3. THE CONSUMERS — the serializer canonicalizes (collapse one arm, drop an
+ *     off-vocabulary arm, dedupe) and the JSX codegen emits a TS union. A
+ *     declaration the gate honours but the `.d.ts` contradicts would just move
+ *     the author's false error one layer over.
+ */
+import { describe, expect, it } from 'vitest';
+import {
+  canonicalizeInputType,
+  compile,
+  generateDts,
+  inputTypeArms,
+  manifestFromConfigs,
+  validateTree,
+} from '../index.js';
+import type { Manifest, SchemaElement } from '../types.js';
+
+const one = (inputs: Parameters<typeof manifestFromConfigs>[0][number]['inputs']): Manifest =>
+  manifestFromConfigs([{ type: 'probe', namespace: 'ui', inputs }]);
+
+const codes = (manifest: Manifest, node: Record<string, unknown>): string[] =>
+  validateTree({ type: 'probe', ...node } as SchemaElement, manifest).diagnostics.map(
+    (d) => d.code,
+  );
+
+const messages = (manifest: Manifest, node: Record<string, unknown>): string[] =>
+  validateTree({ type: 'probe', ...node } as SchemaElement, manifest).diagnostics.map(
+    (d) => d.message,
+  );
+
+describe('any declared arm accepts the value', () => {
+  const manifest = one([{ name: 'title', type: ['string', 'object'] }]);
+
+  it('accepts either arm', () => {
+    expect(codes(manifest, { title: 'Account' })).toEqual([]);
+    expect(codes(manifest, { title: { en: 'Account', 'zh-CN': '客户' } })).toEqual([]);
+  });
+
+  it('still reports a value that matches NO arm — the union is not an opt-out', () => {
+    // The control for fact 1. Every "accepts" assertion above would also pass if
+    // the coarse check had stopped running altogether.
+    expect(codes(manifest, { title: 42 })).toContain('type-mismatch');
+    expect(codes(manifest, { title: true })).toContain('type-mismatch');
+    expect(codes(manifest, { title: ['Account'] })).toContain('type-mismatch');
+  });
+
+  it('names every arm in the message, once, in declaration order', () => {
+    expect(messages(manifest, { title: 42 })).toEqual([
+      '<probe> prop "title" expected a string or an object',
+    ]);
+  });
+
+  it('reports one diagnostic per prop, not one per failed arm', () => {
+    expect(codes(manifest, { title: 42 })).toHaveLength(1);
+  });
+
+  it('reports at the STRICTEST arm severity when an enum arm is present', () => {
+    // An enum's closed list is the one fact this layer is certain about, so
+    // adding a second arm beside it must not turn its verdict into a dismissible
+    // warning. The code becomes `type-mismatch` (the fact is "fits none of the
+    // arms") while the message still carries the allowed values.
+    const withEnum = one([{ name: 'size', type: ['number', 'enum'], enum: ['sm', 'lg'] }]);
+    expect(codes(withEnum, { size: 12 })).toEqual([]);
+    expect(codes(withEnum, { size: 'lg' })).toEqual([]);
+
+    const bad = validateTree(
+      { type: 'probe', size: 'enormous' } as SchemaElement,
+      withEnum,
+    ).diagnostics;
+    expect(bad).toHaveLength(1);
+    expect(bad[0]).toMatchObject({ severity: 'error', code: 'type-mismatch' });
+    expect(bad[0].message).toContain('one of ["sm","lg"]');
+  });
+
+  it('a `slot` arm keeps accepting everything', () => {
+    // Preserves the pre-union `default: return null` branch: a slot describes a
+    // child position, not a value, and those inputs never drew a diagnostic.
+    const slotty = one([{ name: 'footer', type: 'slot' }]);
+    expect(codes(slotty, { footer: 'anything' })).toEqual([]);
+    expect(codes(slotty, { footer: { deeply: ['nested'] } })).toEqual([]);
+  });
+});
+
+describe('a single-kind declaration is unchanged (backward compatibility)', () => {
+  it('produces the same messages it always did', () => {
+    const manifest = one([
+      { name: 's', type: 'string' },
+      { name: 'n', type: 'number' },
+      { name: 'b', type: 'boolean' },
+      { name: 'a', type: 'array' },
+      { name: 'o', type: 'object' },
+      { name: 'c', type: 'color' },
+    ]);
+    expect(messages(manifest, { s: 1 })).toEqual(['<probe> prop "s" expected a string']);
+    expect(messages(manifest, { n: 'x' })).toEqual(['<probe> prop "n" expected a number']);
+    expect(messages(manifest, { b: 'x' })).toEqual(['<probe> prop "b" expected a boolean']);
+    expect(messages(manifest, { a: {} })).toEqual(['<probe> prop "a" expected an array']);
+    expect(messages(manifest, { o: [] })).toEqual(['<probe> prop "o" expected an object']);
+    // `color` is a string with a narrower control — its message was, and stays,
+    // the string one.
+    expect(messages(manifest, { c: 1 })).toEqual(['<probe> prop "c" expected a string']);
+  });
+
+  it('keeps `invalid-enum` at error severity for a lone enum arm', () => {
+    // The one code that is NOT `type-mismatch`, and the severity a silent
+    // fallback would hide behind (objectui#3985). A lone enum arm must keep both.
+    const manifest = one([{ name: 'mode', type: 'enum', enum: ['a', 'b'] }]);
+    const d = validateTree({ type: 'probe', mode: 'c' } as SchemaElement, manifest).diagnostics;
+    expect(d).toHaveLength(1);
+    expect(d[0]).toMatchObject({ severity: 'error', code: 'invalid-enum' });
+    expect(d[0].message).toBe('<probe> prop "mode"="c" is not one of ["a","b"]');
+  });
+
+  it('serializes to the bare string, so an existing manifest is byte-identical', () => {
+    const before = one([{ name: 'title', type: 'string' }]);
+    expect(before.components.probe.inputs[0].type).toBe('string');
+    expect(JSON.stringify(before)).toContain('"type":"string"');
+  });
+});
+
+describe('canonicalizeInputType — what reaches the published manifest', () => {
+  it('collapses a one-element array to the bare kind', () => {
+    // So a union declaration that happens to have one arm cannot fork the
+    // published shape into two spellings of one meaning.
+    expect(canonicalizeInputType(['string'])).toBe('string');
+    expect(one([{ name: 'x', type: ['string'] }]).components.probe.inputs[0].type).toBe('string');
+  });
+
+  it('de-duplicates repeated arms', () => {
+    expect(canonicalizeInputType(['string', 'string'])).toBe('string');
+    expect(canonicalizeInputType(['string', 'object', 'string'])).toEqual(['string', 'object']);
+  });
+
+  it('preserves arm order for a real union', () => {
+    expect(canonicalizeInputType(['object', 'string'])).toEqual(['object', 'string']);
+  });
+
+  it('coerces a lone off-vocabulary kind to `string`, as it always did', () => {
+    expect(canonicalizeInputType('i18nString')).toBe('string');
+    expect(canonicalizeInputType(undefined)).toBe('string');
+  });
+
+  it('DROPS an off-vocabulary arm from a union instead of coercing it', () => {
+    // Coercing would publish a `'string'` arm the author never declared — a
+    // widening invented by the serializer. The surviving arms carry the
+    // declaration, so the unknown one is dropped.
+    expect(canonicalizeInputType(['object', 'i18nString'])).toBe('object');
+    expect(canonicalizeInputType(['number', 'nope', 'boolean'])).toEqual(['number', 'boolean']);
+    // …and if that empties the array, the lone-unknown fallback applies, because
+    // a manifest input must always carry a valid kind.
+    expect(canonicalizeInputType(['nope', 'alsoNope'])).toBe('string');
+    expect(canonicalizeInputType([])).toBe('string');
+  });
+
+  it('is what the gate reads — a dropped arm is not silently honoured', () => {
+    const manifest = one([{ name: 'title', type: ['object', 'i18nString'] as never }]);
+    expect(codes(manifest, { title: { en: 'x' } })).toEqual([]);
+    expect(codes(manifest, { title: 'x' })).toContain('type-mismatch');
+  });
+});
+
+describe('inputTypeArms', () => {
+  it('normalizes both declaration forms', () => {
+    expect(inputTypeArms('string')).toEqual(['string']);
+    expect(inputTypeArms(['string', 'number'])).toEqual(['string', 'number']);
+    expect(inputTypeArms(undefined)).toEqual([]);
+  });
+});
+
+describe('generateDts emits the union it validates', () => {
+  it('emits a TypeScript union for a multi-arm input', () => {
+    const dts = generateDts(
+      one([
+        { name: 'title', type: ['string', 'object'], required: true },
+        { name: 'defaultValue', type: ['string', 'number'] },
+      ]),
+    );
+    expect(dts).toContain('title: string | Record<string, unknown>;');
+    expect(dts).toContain('defaultValue?: string | number;');
+  });
+
+  it('de-duplicates arms that collapse to the same TS type', () => {
+    const dts = generateDts(one([{ name: 'tint', type: ['string', 'color'] }]));
+    expect(dts).toContain('tint?: string;');
+    expect(dts).not.toContain('string | string');
+  });
+
+  it('emits an enum arm as its literal union, beside the other arms', () => {
+    const dts = generateDts(one([{ name: 'size', type: ['enum', 'number'], enum: ['sm', 'lg'] }]));
+    expect(dts).toContain('size?: "sm" | "lg" | number;');
+  });
+
+  it('omits an input whose only arm is a slot, and keeps one that has a value arm', () => {
+    const dts = generateDts(
+      one([
+        { name: 'footer', type: 'slot' },
+        { name: 'caption', type: ['slot', 'string'] },
+      ]),
+    );
+    expect(dts).not.toContain('footer');
+    // The old test was `i.type !== 'slot'`, which this union passes; the type is
+    // taken from the value arms only, so the slot arm contributes nothing.
+    expect(dts).toContain('caption?: string;');
+  });
+});
+
+describe('the union survives the whole compile pipeline', () => {
+  it('compiles a JSX page that writes either arm', () => {
+    const manifest = one([{ name: 'title', type: ['string', 'object'] }]);
+    expect(compile(`<probe title="Account" />`, manifest).diagnostics).toEqual([]);
+    expect(
+      compile(`<probe title={{ "en": "Account", "zh-CN": "客户" }} />`, manifest).diagnostics,
+    ).toEqual([]);
+    expect(compile(`<probe title={42} />`, manifest).diagnostics.map((d) => d.code)).toContain(
+      'type-mismatch',
+    );
+  });
+});
diff --git a/packages/sdui-parser/src/__tests__/node-slot-walk-11170.test.ts b/packages/sdui-parser/src/__tests__/node-slot-walk-11170.test.ts
new file mode 100644
index 00000000000..c979d156716
--- /dev/null
+++ b/packages/sdui-parser/src/__tests__/node-slot-walk-11170.test.ts
@@ -0,0 +1,106 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE-MIT file beside this package's manifest.
+ */
+
+/**
+ * `validateTree` descends the node slots a component's manifest entry carries
+ * (objectui#11170), and `manifestFromConfigs` projects them from the one
+ * declaration it is handed through `slotsFor`.
+ *
+ * The subject under every slot is a tag the manifest does not know, so what
+ * each case measures is REACH: `unknown-component` on the same node, drawn or
+ * not drawn, decided by whether its position is a declared slot. The
+ * declaration used here is a stand-in with the real grammar — this package
+ * imports nothing at runtime — and the components-side census for the same
+ * card holds this walk and `@object-ui/types`' `nodeSlotValues` to one answer
+ * over the live declaration.
+ */
+import { describe, expect, it } from 'vitest';
+import { manifestFromConfigs, validateTree } from '../index.js';
+import type { Diagnostic, SchemaElement } from '../types.js';
+
+const SLOTS: Record<string, { path: string; retired?: boolean }[]> = {
+  dialog: [{ path: 'trigger' }, { path: 'content' }, { path: 'footer' }],
+  tabs: [{ path: 'items[].content' }],
+  carousel: [{ path: 'items[]' }],
+  'report-viewer': [{ path: 'report.sections[].content' }],
+  'page:card': [{ path: 'footer' }, { path: 'body', retired: true }],
+};
+const slotsFor = (type: string) => SLOTS[type] ?? [];
+
+const CONFIGS = [
+  { type: 'dialog', namespace: 'ui', inputs: [{ name: 'trigger', type: 'slot' }, { name: 'content', type: 'slot' }, { name: 'footer', type: 'slot' }] },
+  { type: 'tabs', namespace: 'ui', inputs: [{ name: 'items', type: 'array' }] },
+  { type: 'carousel', namespace: 'ui', inputs: [{ name: 'items', type: 'array' }] },
+  { type: 'report-viewer', namespace: 'plugin-report', inputs: [{ name: 'report', type: 'code' }] },
+  { type: 'page:card', namespace: 'page', inputs: [{ name: 'children', type: 'slot' }, { name: 'footer', type: 'slot' }] },
+  { type: 'text', namespace: 'ui', inputs: [{ name: 'content', type: 'string' }] },
+] as unknown as Parameters<typeof manifestFromConfigs>[0];
+
+const withSlots = manifestFromConfigs(CONFIGS, { slotsFor });
+const withoutSlots = manifestFromConfigs(CONFIGS);
+
+const UNKNOWN = { type: 'nope-11170' };
+const codes = (node: unknown, manifest = withSlots): string[] =>
+  validateTree(node as SchemaElement, manifest).diagnostics.map((d: Diagnostic) => d.code);
+const unknownCount = (node: unknown, manifest = withSlots) =>
+  codes(node, manifest).filter((c) => c === 'unknown-component').length;
+
+describe('manifestFromConfigs projects the declaration it is handed (objectui#11170)', () => {
+  it('carries each entry’s non-retired slot paths, and no key at all without the option', () => {
+    expect(withSlots.components['dialog']!.slots).toEqual(['trigger', 'content', 'footer']);
+    expect(withSlots.components['tabs']!.slots).toEqual(['items[].content']);
+    // The retired `body` is left out of the authoring tier's projection.
+    expect(withSlots.components['page:card']!.slots).toEqual(['footer']);
+    // An entry with no slots publishes none (`undefined`, which `JSON.stringify`
+    // drops — the same contract `tier` and `of` keep), so the serialised entry
+    // is byte-identical to one built before the key existed.
+    expect(withSlots.components['text']!.slots).toBeUndefined();
+    expect(JSON.stringify(withSlots.components['text'])).toBe(JSON.stringify(withoutSlots.components['text']));
+    expect(JSON.stringify(withoutSlots)).not.toContain('"slots"');
+  });
+});
+
+describe('validateTree reaches slot-held nodes exactly where the entry declares a slot', () => {
+  it('a direct slot, one node or a list', () => {
+    expect(unknownCount({ type: 'dialog', content: UNKNOWN })).toBe(1);
+    expect(unknownCount({ type: 'dialog', content: [{ type: 'text' }, UNKNOWN], footer: UNKNOWN })).toBe(2);
+    // The same node under an undeclared key is not reached.
+    expect(unknownCount({ type: 'dialog', header: UNKNOWN })).toBe(0);
+  });
+
+  it('a panel list and a trailing `[]`', () => {
+    expect(unknownCount({ type: 'tabs', items: [{ value: 'a', content: UNKNOWN }, { value: 'b', content: [UNKNOWN, UNKNOWN] }] })).toBe(3);
+    expect(unknownCount({ type: 'carousel', items: [UNKNOWN, [UNKNOWN]] })).toBe(2);
+    expect(unknownCount({ type: 'report-viewer', report: { sections: [{ content: UNKNOWN }] } })).toBe(1);
+  });
+
+  it('nested: a slot under a child under a slot', () => {
+    const doc = { type: 'dialog', content: { type: 'tabs', items: [{ value: 'a', content: UNKNOWN }] } };
+    expect(unknownCount(doc)).toBe(1);
+  });
+
+  it('a retired position is not walked by this tier; its refusal by name stands (objectui#6771)', () => {
+    const diagnostics = validateTree({ type: 'page:card', body: [UNKNOWN] } as unknown as SchemaElement, withSlots).diagnostics;
+    expect(diagnostics.filter((d) => d.code === 'unknown-component')).toEqual([]);
+    expect(diagnostics.map((d) => d.code)).toContain('unknown-prop');
+    expect(diagnostics.find((d) => d.code === 'unknown-prop')?.message).toContain('"body" is its retired spelling');
+  });
+
+  it('a manifest without slots walks `children` alone — the pre-11170 reach, unchanged', () => {
+    expect(unknownCount({ type: 'dialog', content: UNKNOWN }, withoutSlots)).toBe(0);
+    expect(unknownCount({ type: 'dialog', children: [UNKNOWN] }, withoutSlots)).toBe(1);
+  });
+
+  it('an unknown component’s own slots are not consulted: one diagnostic, on it', () => {
+    expect(codes({ type: 'nope-outer', content: UNKNOWN })).toEqual(['unknown-component']);
+  });
+
+  it('a string in a slot is legal and draws nothing', () => {
+    expect(codes({ type: 'dialog', trigger: 'Open', content: ['plain', { type: 'text' }] })).toEqual([]);
+  });
+});
diff --git a/packages/sdui-parser/src/__tests__/provenance.test.ts b/packages/sdui-parser/src/__tests__/provenance.test.ts
new file mode 100644
index 00000000000..fc6db1d41bb
--- /dev/null
+++ b/packages/sdui-parser/src/__tests__/provenance.test.ts
@@ -0,0 +1,128 @@
+/**
+ * html-tier provenance marking (objectui#4000).
+ *
+ * The parser stamps every element it emits, so a renderer can tell an html-tier
+ * node from a JSON-authored one and scope authoring advice to the surface the
+ * advice is actually about. What is pinned here is the marker's four load-
+ * bearing properties, each of which has a distinct failure mode:
+ *
+ *  - it is SET on what the parser produces, at every depth;
+ *  - it SURVIVES an object spread — `SchemaRenderer` hands renderers a shallow
+ *    copy, so a marker that did not survive would restore the original bug in
+ *    the render path only, silently;
+ *  - it is INVISIBLE to JSON — so it cannot be persisted, and therefore cannot
+ *    be replayed by an authored document that wants the exemption;
+ *  - it is NOT set on JSON reached through a braced attribute — that JSON was
+ *    hand-written, so the JSON surface's advice does apply to it.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { parseJsx } from '../parse.js';
+import { HTML_TIER_NODE, isHtmlTierNode, markHtmlTierNode } from '../provenance.js';
+import type { SchemaElement } from '../types.js';
+
+describe('html-tier provenance (#4000)', () => {
+  it('marks every element the parser emits, at every depth', () => {
+    const { tree } = parseJsx('<div className="outer"><span><em>deep</em></span></div>');
+    const root = tree as SchemaElement;
+    expect(isHtmlTierNode(root)).toBe(true);
+
+    const child = root.children![0] as SchemaElement;
+    expect(isHtmlTierNode(child)).toBe(true);
+    const grandchild = child.children![0] as SchemaElement;
+    expect(isHtmlTierNode(grandchild)).toBe(true);
+  });
+
+  it('survives the shallow copy a renderer receives', () => {
+    // `SchemaRenderer` evaluates expressions against `{ ...schema }` and passes
+    // the COPY down. Object spread carries own enumerable symbol keys and drops
+    // non-enumerable ones — so this assertion, not the definition site, is what
+    // actually holds the marker's descriptor in place.
+    const { tree } = parseJsx('<div className="a" />');
+    const copy = { ...(tree as SchemaElement) };
+    expect(isHtmlTierNode(copy)).toBe(true);
+
+    // …and through a second hop, which is what nesting plus scoped styling does.
+    expect(isHtmlTierNode({ ...copy, className: 'a scoped' })).toBe(true);
+  });
+
+  it('is invisible to JSON, to Object.keys and to for...in', () => {
+    const { tree } = parseJsx('<div className="a" />');
+    const root = tree as SchemaElement;
+
+    expect(JSON.parse(JSON.stringify(root))).toEqual({ type: 'div', className: 'a' });
+    // ⚠️ Key ORDER, not key SET: `type` moved from first to last when the
+    // discriminator collision was closed (objectui#7235) and the node became
+    // `{ ...props, type: tag }`. The set, the values and the round-trip are
+    // unchanged — this line is the one visible consequence of that reversal,
+    // and it is here rather than adjusted away because an order pin that
+    // silently follows the implementation pins nothing.
+    expect(Object.keys(root)).toEqual(['className', 'type']);
+    const seen: string[] = [];
+    for (const k in root) seen.push(k);
+    expect(seen).toEqual(['className', 'type']);
+
+    // The round-trip is the anti-forgery pin: a persisted tree comes back
+    // unmarked, so a saved (or AI-generated) document cannot carry the
+    // exemption back in with it.
+    expect(isHtmlTierNode(JSON.parse(JSON.stringify(root)))).toBe(false);
+  });
+
+  it('survives the reversed spread — the marking is applied AFTER every key', () => {
+    // objectui#7235 reversed `markHtmlTierNode({ type: tag, ...props })` into
+    // `markHtmlTierNode({ ...props, type: tag })`. Until objectstack#25712 made
+    // the two copies of this parser one, only the renderer's copy stamped, so
+    // the reversal was the one edit in that port where the stamp could have
+    // been dropped — e.g. by moving the call inside the literal, or by
+    // spreading a marked object into a fresh unmarked one. Pinned at every depth
+    // and for the shapes the reversal actually moves: props present, props
+    // absent, and a container whose children were attached after the stamp.
+    const { tree } = parseJsx('<flex direction="col" gap={4}><grid columns={2} /><div /></flex>');
+    const root = tree as SchemaElement;
+
+    expect(isHtmlTierNode(root)).toBe(true);
+    expect(root.type).toBe('flex');
+    // `children` is assigned after `markHtmlTierNode` returns; the stamp is on
+    // the same object, so it must still read true once they are attached.
+    expect(root.children).toHaveLength(2);
+    for (const child of root.children as SchemaElement[]) {
+      expect(isHtmlTierNode(child)).toBe(true);
+    }
+    // The propless element — `{ ...{}, type: tag }` — is the degenerate case
+    // of the reversal and has its own way of going wrong.
+    expect(isHtmlTierNode((root.children as SchemaElement[])[1])).toBe(true);
+  });
+
+  it('does not mark JSON smuggled in through a braced attribute', () => {
+    // The parser produces the element; the object inside the braces is
+    // hand-written JSON that merely rode along. Marking it would hand the
+    // exemption to authored metadata — the precise over-reach this mechanism
+    // exists to avoid.
+    const { tree } = parseJsx('<page body={[{"type":"div","className":"inner"}]} />');
+    const root = tree as SchemaElement;
+    expect(isHtmlTierNode(root)).toBe(true);
+
+    const smuggled = (root.body as SchemaElement[])[0];
+    expect(smuggled.type).toBe('div');
+    expect(isHtmlTierNode(smuggled)).toBe(false);
+  });
+
+  it('reads false for anything unmarked, and never throws on non-objects', () => {
+    expect(isHtmlTierNode({ type: 'div' })).toBe(false);
+    expect(isHtmlTierNode(null)).toBe(false);
+    expect(isHtmlTierNode(undefined)).toBe(false);
+    expect(isHtmlTierNode('div')).toBe(false);
+    expect(isHtmlTierNode(7)).toBe(false);
+    // A string-keyed lookalike is not provenance — there is no fallback read.
+    expect(isHtmlTierNode({ type: 'div', _provenance: 'html' })).toBe(false);
+  });
+
+  it('keys the marker in the global registry, so duplicate instances agree', () => {
+    // This package ships ESM and CJS and is consumed from several packages. Two
+    // module instances holding two local symbols would not compare equal, and
+    // the failure mode of that mismatch is the original bug returning with no
+    // error anywhere. A registry key cannot drift.
+    expect(HTML_TIER_NODE).toBe(Symbol.for('@object-ui/sdui-parser.html-tier-node'));
+    expect(isHtmlTierNode(markHtmlTierNode({ type: 'div' }))).toBe(true);
+  });
+});
diff --git a/packages/sdui-parser/src/__tests__/tier.test.ts b/packages/sdui-parser/src/__tests__/tier.test.ts
new file mode 100644
index 00000000000..70b524dbf47
--- /dev/null
+++ b/packages/sdui-parser/src/__tests__/tier.test.ts
@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+import { assertFullyLoaded, generateBlockList, generateDts, manifestFromConfigs } from '../index.js';
+
+const configs = [
+  { type: 'object-table', namespace: 'plugin-grid', tier: 'public' as const, inputs: [
+    { name: 'object', type: 'string', required: true, binding: 'object' as const }, { name: 'pageSize', type: 'number' } ] },
+  { type: 'flex', namespace: 'ui', tier: 'public' as const, isContainer: true, inputs: [{ name: 'gap', type: 'number' }] },
+  { type: 'studio-metadata-admin', namespace: 'app-shell', tier: 'internal' as const, inputs: [] },
+  { type: 'debug-overlay', namespace: 'app-shell', inputs: [] },
+];
+
+describe('M4: capability vs contract (tier)', () => {
+  it('publicOnly keeps only the curated tier', () => {
+    expect(Object.keys(manifestFromConfigs(configs, { publicOnly: true }).components).sort())
+      .toEqual(['flex', 'object-table']);
+  });
+  it('unfiltered keeps the full capability', () => {
+    expect(Object.keys(manifestFromConfigs(configs).components)).toHaveLength(4);
+  });
+  it('generates the block list 清单 with bindings', () => {
+    const list = generateBlockList(manifestFromConfigs(configs, { publicOnly: true }));
+    expect(list).toContain('# SDUI public blocks (2)');
+    expect(list).toContain('object:object');
+  });
+  it('codegen stays consistent with the public manifest', () => {
+    expect(generateDts(manifestFromConfigs(configs, { publicOnly: true })))
+      .toContain('"object-table": ObjectTableProps;');
+  });
+});
+
+describe('assertFullyLoaded — generators must not emit lazy stubs (objectui#2953)', () => {
+  it('passes when every config is a loaded registration', () => {
+    expect(() => assertFullyLoaded(configs)).not.toThrow();
+  });
+
+  it('names every stub, so the fix is "import these plugins"', () => {
+    const withStubs = [
+      ...configs,
+      { type: 'object-kanban', namespace: 'plugin-kanban', lazy: true },
+      { type: 'object-map', namespace: 'plugin-map', lazy: true },
+    ];
+    // The silent alternative is what this exists to prevent: both blocks reach
+    // the manifest with `inputs: []`, which reads as "takes no props" and turns
+    // every prop an author writes into an unknown-prop diagnostic.
+    expect(manifestFromConfigs(withStubs).components['object-kanban'].inputs).toEqual([]);
+    expect(() => assertFullyLoaded(withStubs)).toThrow(/object-kanban, object-map/);
+    expect(() => assertFullyLoaded(withStubs)).toThrow(/2 not-yet-loaded lazy block/);
+  });
+});
diff --git a/packages/sdui-parser/src/__tests__/type-attribute-collision.test.ts b/packages/sdui-parser/src/__tests__/type-attribute-collision.test.ts
index 75b78de7a63..2c513d31e80 100644
--- a/packages/sdui-parser/src/__tests__/type-attribute-collision.test.ts
+++ b/packages/sdui-parser/src/__tests__/type-attribute-collision.test.ts
@@ -12,6 +12,8 @@
 import { describe, expect, it } from 'vitest';
 import { compile, manifestFromConfigs } from '../index.js';
 import { parseJsx } from '../parse.js';
+import { isHtmlTierNode } from '../provenance.js';
+import type { SchemaElement } from '../types.js';
 
 const manifest = manifestFromConfigs([
   { type: 'flex', namespace: 'ui', isContainer: true, inputs: [
@@ -78,6 +80,29 @@ describe('an authored `type` attribute is refused (the discriminator collision)'
     expect(r.diagnostics).toEqual([]);
     expect(r.tree).toMatchObject({ type: 'flex', direction: 'row', gap: 4 });
   });
+
+  it('a node with NO `type` attribute keeps the same keys, values and provenance', () => {
+    // The regression guard, stated as what was actually measured. ⚠️ It is NOT
+    // byte-identical to the pre-change output: reversing the spread moves
+    // `type` from FIRST key to LAST, so `JSON.stringify` emits the same pairs
+    // in a different order. The key SET, every value, the children and the
+    // html-tier marker are unchanged, and that is the whole of the difference —
+    // `provenance.test.ts` carries the order pin itself.
+    const { tree, diagnostics } = parseJsx('<flex direction="col" gap={8} wrap><grid columns={3} /></flex>');
+    const root = tree as SchemaElement;
+
+    expect(diagnostics).toEqual([]);
+    expect(root).toMatchObject({
+      type: 'flex',
+      direction: 'col',
+      gap: 8,
+      wrap: true,
+      children: [{ type: 'grid', columns: 3 }],
+    });
+    expect(Object.keys(root).sort()).toEqual(['children', 'direction', 'gap', 'type', 'wrap']);
+    expect(isHtmlTierNode(root)).toBe(true);
+    expect(isHtmlTierNode(root.children![0])).toBe(true);
+  });
 });
 
 /**
@@ -86,7 +111,7 @@ describe('an authored `type` attribute is refused (the discriminator collision)'
  * The order fix is DEFENSE IN DEPTH, which means the refusal makes it
  * unobservable through the public API: measured by ablation on the committed
  * tree, restoring `{ type: tag, ...props }` while LEAVING the refusal in place
- * keeps all eight of these tests GREEN, because the refused attribute never
+ * keeps all nine of these tests GREEN, because the refused attribute never
  * reaches `props` to be spread. What turns them red is removing the refusal
  * (5 red) and, additionally, the two spread-order assertions here when BOTH
  * halves are removed together (6 red).
diff --git a/packages/sdui-parser/src/body-dialect.ts b/packages/sdui-parser/src/body-dialect.ts
new file mode 100644
index 00000000000..6176d25ba8f
--- /dev/null
+++ b/packages/sdui-parser/src/body-dialect.ts
@@ -0,0 +1,106 @@
+/*! Moved into @objectstack/sdui-parser from @object-ui/sdui-parser
+ * (objectstack#25712); this file keeps the licence it was written under.
+ * MIT License. Copyright (c) 2024 ObjectQL. The full permission notice ships
+ * as LICENSE-MIT beside this package's manifest. */
+
+/**
+ * ObjectUI — the retired `body` child-list dialect (objectui#6771)
+ *
+ * `body` was a declared twin of `children` on `BaseSchema`, and for a long
+ * while it was the ONLY child-list key a dozen registrations read. This tier
+ * never knew it: `BASE_PROPS` lists `children` and not `body`, so the one
+ * spelling that resolved drew `unknown-prop` — the same warning a typo draws,
+ * on the tier built to accept AI-authored pages, where the diagnostic IS the
+ * contract. The maintainer ruled the retirement (2026-09-01, option B): one
+ * concept, one spelling, and the spelling is `children`.
+ *
+ * This module is the tier's half of that ruling. It REPLACES the diagnostic the
+ * prop walk would otherwise emit for `body`, rather than adding to it — two
+ * diagnostics for one mistake is the shape `checkMemberTypes` already refuses
+ * (objectui#8067).
+ *
+ * WHY A REPLACEMENT AND NOT A BARE `unknown-prop`. After the retirement
+ * "`<badge>` has no prop body" is TRUE — but it is the answer that sent authors
+ * the wrong way in the first place. Every `body` node in this repository's own
+ * docs, examples and READMEs was migrated in the same change, and an author
+ * carrying the old spelling in from anywhere else needs the replacement NAMED,
+ * not merely the key refused. The two codes below are the ruling's own words:
+ * the tier teaches `children` only, and a `body` child list under a
+ * non-container draws the same `not-a-container` the `children` spelling draws.
+ *
+ * SCOPE — asked INSIDE the `!input` branch, because its claim is about a key
+ * nobody declares, so a
+ * component that publishes its own `body` input keeps its declared type check
+ * untouched. Re-derived against the registry rather than recalled: exactly one
+ * registration in the tree declares an input named `body`, and it is
+ * `record:alert` (`plugin-detail`, `register('alert', …, { namespace: 'record' })`),
+ * whose `body` takes an inline translation map and is not this spelling.
+ * Control on the same sweep: `name: 'children'` fires seven times.
+ */
+
+import type { Diagnostic, ParsedSchemaNode } from './types.js';
+
+/** The child-list spelling objectui#6771 retired. `children` replaced it. */
+export const RETIRED_CHILD_LIST_KEY = 'body';
+
+const isPlainObject = (v: unknown): v is Record<string, unknown> =>
+  typeof v === 'object' && v !== null && !Array.isArray(v);
+
+/**
+ * Is this value shaped like the child list the dialect used to carry?
+ *
+ * A list of nodes, or the bare single node `FlatContent` and `renderChildren`
+ * have always accepted. A scalar is not — `body="hi"` is a dead key and nothing
+ * more, so it does not get the containment sentence, which would name a shape
+ * its author did not write.
+ */
+const isChildList = (value: unknown): value is ParsedSchemaNode | ParsedSchemaNode[] =>
+  Array.isArray(value) || isPlainObject(value);
+
+/**
+ * The diagnostic for an authored `body`, or `null` when this module has nothing
+ * to say about the key.
+ *
+ * @param tag              the node's component type, for the message and the `tag` field
+ * @param key              the authored prop name
+ * @param value            its authored value
+ * @param acceptsChildren  whether the component declares the `children` slot
+ *                         input — `acceptsChildren(comp)` in `./validate.ts`,
+ *                         the ONE containment predicate this tier has. It used
+ *                         to be `comp.isContainer`; objectui#9910 moved both
+ *                         sites together so the retired spelling and the live
+ *                         one can never disagree about who takes a list.
+ */
+export function checkRetiredBodyDialect(
+  tag: string,
+  key: string,
+  value: unknown,
+  acceptsChildren: boolean,
+): Diagnostic | null {
+  if (key !== RETIRED_CHILD_LIST_KEY) return null;
+
+  if (isChildList(value) && !acceptsChildren) {
+    // The ruling, verbatim: "a `body` child list under a non-container draws
+    // the same `not-a-container` the `children` spelling draws". Same code, so
+    // a consumer keying on the code cannot tell the two spellings apart — which
+    // is the single-spelling rule stated in the diagnostic stream. The sentence
+    // carries the extra fact the `children` path has no need of.
+    return {
+      severity: 'warning',
+      code: 'not-a-container',
+      message:
+        `<${tag}> does not accept children — and "body" is the retired spelling of ` +
+        `"children", so this child list has no door here at all`,
+      tag,
+    };
+  }
+
+  return {
+    severity: 'warning',
+    code: 'unknown-prop',
+    message:
+      `<${tag}> has no prop "body" — the child-list key is "children" ` +
+      `("body" is its retired spelling)`,
+    tag,
+  };
+}
diff --git a/packages/sdui-parser/src/codegen.ts b/packages/sdui-parser/src/codegen.ts
index c598ce9a383..223f847ab71 100644
--- a/packages/sdui-parser/src/codegen.ts
+++ b/packages/sdui-parser/src/codegen.ts
@@ -55,8 +55,9 @@ export function generateDts(manifest: Manifest, options: CodegenOptions = {}): s
     interface ElementChildrenAttribute { children: object; }`
     : '';
 
-  return `// AUTO-GENERATED by @object-ui/sdui-parser — DO NOT EDIT.
+  return `// AUTO-GENERATED by @objectstack/sdui-parser — DO NOT EDIT.
 // Source of truth: ComponentRegistry inputs (ADR-0080 §3). Regenerate via codegen.
+/* eslint-disable */
 
 ${emitBaseProps()}
 
diff --git a/packages/sdui-parser/src/dashboard-widget-options.ts b/packages/sdui-parser/src/dashboard-widget-options.ts
index 91f96339130..d3941813a90 100644
--- a/packages/sdui-parser/src/dashboard-widget-options.ts
+++ b/packages/sdui-parser/src/dashboard-widget-options.ts
@@ -1,6 +1,5 @@
 /**
- * Unconsumed dashboard-widget `options` keys (objectui#5709), ported into this
- * copy in lockstep (objectstack#12810).
+ * Unconsumed dashboard-widget `options` keys (objectui#5709)
  *
  * `@objectstack/spec`'s `DashboardWidgetOptionsSchema` ends in `.passthrough()`
  * ("declared query keys + open renderer extras"), so ANY key parses, validates
@@ -12,91 +11,107 @@
  * renderer draws a WARNING naming the consumed set. Not an error: no gate
  * weakening and no new red gates were ruled.
  *
- * ## LOCKSTEP — what is byte-equal here and what deliberately is not
+ * ## The census (measured on objectui origin/main @ 8689166f6, spec 17.1.0)
  *
- * Two copies of this parser exist: objectui's `packages/sdui-parser` and this
- * hoisted `@objectstack/sdui-parser`. The invariant they owe each other is that
- * both agree on the accepted grammar AND on diagnostic codes — if they drift,
- * the save gate and the renderer speak different dialects and a page can save
- * clean and render inert, or the reverse (objectstack#12719, objectstack#12810).
- *
- * Everything from the `import` line below to end of file is a byte-equal port of
- * objectui's `src/dashboard-widget-options.ts` SAVE FOR ONE TOKEN, called out
- * at the site itself: the emitted `code` is spelled as an inline literal here
- * and as the constant there, because this repo runs a vocabulary gate objectui
- * does not. One census MEMBER differs too, for a bounded window: objectui's
- * copy at the pin still lists `description`, which this one dropped with the
- * retired metric sub-caption (see `CONSUMED_WIDGET_OPTION_KEYS`). The emitted `code`, `severity`, `message` and the whole census
- * scope are identical, and `__tests__/dashboard-widget-options.test.ts`
- * re-derives that rather than trusting it — including an explicit pin that the
- * literal equals `UNCONSUMED_WIDGET_OPTION`. Change these functions only
- * together with the objectui copy.
- *
- * THIS HEADER is the one deliberate divergence, and it has to be: objectui's
- * header cites the maintenance machinery that derives the census — its
- * `DatasetWidget.tsx` / `DashboardRenderer.tsx` read sites, its
- * `plugin-dashboard.mdx` claim and its two census tests. NONE of those files
- * exists in this repo (measured: no dashboard renderer package here at all), so
- * copying those sentences would ship claims this checkout cannot support and
- * nothing here would ever notice them going false. What follows instead states
- * where each half of the census is derivable, and from what.
- *
- * ## The accepted set, and where each half is authoritative
- *
- * The spec REQUIRES `dataset` on every widget (`DashboardWidgetSchema`, this
- * repo: `packages/spec/src/ui/dashboard.zod.ts`), and both of objectui's
- * dashboard surfaces route a dataset-bound widget to `DatasetWidget`. On that —
- * the only spec-legal — path the renderer-consumed `options` keys are exactly
- * the five the spec DECLARES:
+ * The spec REQUIRES `dataset` on every widget (`DashboardWidgetSchema` —
+ * re-read for objectui#7293 against the PUBLISHED `@objectstack/spec@17.4.0`,
+ * whose required keys are exactly `id` / `dataset` / `values`), and both of
+ * the renderer's dashboard surfaces route a dataset-bound widget to
+ * `DatasetWidget` (`DashboardRenderer.tsx` renders `<DatasetWidget>` when
+ * `widget.dataset` is set; `DashboardGridLayout.tsx` mirrors the fork,
+ * objectui#4614). On that —
+ * the only spec-legal — path, the renderer-consumed `options` keys are exactly
+ * the five the spec DECLARES, all read as direct `options.<key>` accesses in
+ * `ui/packages/plugin-dashboard/src/DatasetWidget.tsx`:
  *
  *   dateGranularity, sortBy, sortOrder, limit   (query-affecting, framework#3588)
- *   stageOrder                                  (funnel stage order — the only type that reads it)
+ *   stageOrder                                  (funnel/pyramid stage order)
  *
- * and nothing undeclared. `description` used to be the one undeclared member:
- * the metric-card sub-caption channel, which `translateDashboard` overlaid from
- * a `widgets.{id}.subCaption` translation (objectstack#5428 item 4,
- * objectstack#7862), so warning on it would have flagged the platform's own
- * output. Ruling C on objectui#11389 retired that channel at both ends,
- * objectstack first (objectstack#21257): the overlay is gone, the bundle key is
- * a tombstone, and a widget keeps ONE authored description, `widget.description`
- * — never `options.description`. With no writer left, `description` left this
- * census, so an `options.description` now draws the warning like any other key
- * the dataset-bound path is not meant to read.
+ * and nothing else. ⛔ Not `description`: it was the metric-card sub-caption
+ * (objectui#4032 item 4, objectui#7293), read by `DatasetWidget.tsx`'s metric
+ * branch and a resolver both dashboard surfaces called, and fed by the
+ * server's `translateDashboard` overlay of the `widgets.{id}.subCaption`
+ * translation. The spec never declared it. objectui#11389 (ruling C, which
+ * reverses objectstack#5428 item 4) retires it at both ends: objectstack
+ * first, in `@objectstack/spec` 17.7.0 (the overlay is gone and the
+ * translation key is a tombstone), then the readers here. So an authored
+ * `options.description` reaches no renderer and draws this warning like any
+ * other unconsumed key. A widget keeps one authored description,
+ * `widget.description`, the card-header subtitle, which is not an `options`
+ * key and is not judged here.
  *
  * Notably NOT consumed on the path a widget really renders through:
  * `thresholds` and `format`. Both were widely believed to work; both draw this
- * warning, which is the point. Their closure claims are objectui's to derive —
- * `thresholds` by a repo-wide read-site scan there, `format` by the bounded
- * claim that the dataset-bound path formats from the MEASURE's own metadata —
- * and they are NOT restated here as claims about this repo, which has no
- * renderer to make them about.
+ * warning, which is the point. They are NOT the same kind of claim, and since
+ * the 2026-08-25 maintainer ruling (batch adjudication close-out, decision B1 —
+ * a closure claim must be BOUNDED or DERIVABLE, and a claim written in two
+ * places is single-sourced) they are written separately (objectui#6186):
  *
- * ## The drift risk that lives on THIS side
+ *   `thresholds` — zero read sites repo-wide. This paragraph is the CANONICAL
+ *     statement of that closure claim. `ui/content/docs/plugins/plugin-dashboard.mdx`
+ *     used to assert it a second time in its own words; two copies of one
+ *     closure claim drift apart independently and neither knows when the other
+ *     stopped being true, so the page now POINTS here rather than restating it.
+ *     Single-sourcing is what makes this copy load-bearing, so it is DERIVED
+ *     rather than trusted:
+ *     `ui/scripts/__tests__/unconsumed-widget-option-claim-6186.test.ts` re-scans
+ *     every JS/TS file git tracks for an access to a key of that name and fails
+ *     if one appears. Land a renderer that reads it and this module goes red in
+ *     the same run.
+ *   `format` — not read ON THE DATASET-BOUND PATH; the value is formatted with
+ *     the MEASURE's own metadata (`measureField(...).format`, from the dataset
+ *     definition), not from the widget's bag. Deliberately a BOUNDED claim and
+ *     not a repo-wide one: `format` is a live key in other vocabularies, so a
+ *     repo-wide scan would red on a TRUE claim — and an assertion that reds on
+ *     legitimate code gets deleted by the next person who hits it, which puts
+ *     the claim back where it started. Leg 2 of
+ *     `ui/packages/sdui-parser/src/__tests__/dashboard-widget-options-census.test.ts`
+ *     derives exactly this bound: the DatasetWidget read set is the declared
+ *     set, and neither `format` nor `thresholds` is in it. That absence is
+ *     asserted in its OWN right rather than riding on an equality whose
+ *     right-hand side can grow.
+ *
+ * ## The drift risk that lives on the spec side
  *
  * The spec whose `.passthrough()` this reasons about ships from this repo. So
- * the one way this list can go stale HERE is a new DECLARED key landing in
+ * one way this list can go stale is a new DECLARED key landing in
  * `DashboardWidgetOptionsSchema` without landing in the array below: the key
- * would be spec-legal, renderer-consumed on the objectui side, and warned about
- * here — a false positive on legal metadata. `@objectstack/sdui-parser` takes
- * no dependency on `@objectstack/spec` (it is dependency-free and hoistable by
- * design), so that cross-check is not mechanized in this copy; the census test
- * next door pins the array and names the spec file to re-read when it moves.
+ * would be spec-legal, renderer-consumed, and warned about here — a false
+ * positive on legal metadata. `@objectstack/sdui-parser` takes no dependency on
+ * `@objectstack/spec` (it is dependency-free and hoistable by design), so that
+ * direction is held by `scripts/check-widget-option-census.mjs`, which derives
+ * the declared half from the schema source.
  *
  * ## Scope — where the warning deliberately does NOT fire
  *
  *   - Widgets WITHOUT `dataset`: the legacy inline forms (`options.data`
  *     arrays, `provider: 'object'` bags) consume a much larger, spread-shaped
- *     key set, whose true reach is each child component's prop surface. That
- *     form is spec-illegal today (`dataset` is required) and its census would be
- *     the unmaintainable one; skipping it keeps every warning this module emits
- *     a statement about the path the widget actually renders through.
+ *     key set (`{ ...options }` into `metric` / `object-metric` /
+ *     `data-table` / …), whose true reach is each child component's prop
+ *     surface. That form is spec-illegal today (`dataset` is required) and its
+ *     census would be the unmaintainable one; skipping it keeps every warning
+ *     this module emits a statement about the path the widget actually renders
+ *     through.
  *   - Widgets in the legacy COMPONENT format (`widget.component`): `options`
  *     is not part of that contract.
  *   - Widgets carrying the spec's own escape hatch
  *     `suppressWarnings: ['unconsumed-widget-option']` — the spec models
- *     per-widget diagnostic suppression (`DashboardWidgetSchema.suppressWarnings`,
- *     "Build diagnostic rule ids suppressed on this widget"), so an author with
- *     a genuine out-of-band consumer can say so in metadata.
+ *     per-widget diagnostic suppression (`DashboardWidgetSchema`), so an
+ *     author with a genuine out-of-band consumer can say so in metadata.
+ *
+ * ## Maintenance — how this list stays true
+ *
+ * `ui/packages/sdui-parser/src/__tests__/dashboard-widget-options-census.test.ts`
+ * re-runs the census on every test run: it re-derives the five declared keys from the installed
+ * `@objectstack/spec`, re-extracts the `options.<key>` reads from
+ * `DatasetWidget.tsx` source text (and fails loudly if that file gains a
+ * consumption shape the extractor cannot see — a spread, a destructuring, a
+ * computed access), re-checks that the retired sub-caption key has no read
+ * site left in `plugin-dashboard`, and trips on any NEW
+ * file in `ui/packages/*\/src` or `ui/apps/*\/src` that starts reading
+ * `widget.options`. A renderer change that adds or removes a consumed key
+ * fails that test until this list is updated — the cost of keeping this
+ * warning honest is editing ONE array below plus re-reading the census notes.
  */
 import type { Diagnostic, SchemaElement } from './types.js';
 
@@ -115,15 +130,9 @@ export const DASHBOARD_WIDGET_HOST_TYPES: ReadonlySet<string> = new Set([
 
 /**
  * The accepted set: every `options` key with a renderer read site on the
- * dataset-bound path. Alphabetical; the warning message prints it verbatim.
- * Derivation and evidence: file header.
- *
- * ⚠️ One member short of objectui's copy until objectui#11389 lands: objectui's
- * renderer at the pin still reads `options.description` for the retired metric
- * sub-caption, and its census lists it; that card drops the read and the member
- * together. The window errs in the safe direction — this copy warns on a key
- * objectui's strict authoring face already refuses — and no served document
- * carries the key, because its only writer was the retired overlay.
+ * dataset-bound path, which is exactly the set the spec declares.
+ * Alphabetical; the warning message prints it verbatim. Derivation and
+ * evidence: file header.
  */
 export const CONSUMED_WIDGET_OPTION_KEYS: readonly string[] = [
   'dateGranularity',
@@ -173,8 +182,7 @@ export function checkDashboardWidgetOptions(node: SchemaElement): Diagnostic[] {
       if (CONSUMED.has(key)) continue;
       diagnostics.push({
         severity: 'warning',
-        // DIVERGENCE FROM OBJECTUI, and the only one below this file's header:
-        // objectui writes `code: UNCONSUMED_WIDGET_OPTION` here. This repo runs
+        // Spelled as a literal, not as `UNCONSUMED_WIDGET_OPTION`: this repo runs
         // `check:dispatcher-error-vocabulary`, whose `objlitconst` shape reads
         // the SCREAMING_SNAKE constant NAME at a `code:` position and then must
         // reduce it to a literal — and its literal grammar is
diff --git a/packages/sdui-parser/src/index.ts b/packages/sdui-parser/src/index.ts
index 6466b94e212..167da310264 100644
--- a/packages/sdui-parser/src/index.ts
+++ b/packages/sdui-parser/src/index.ts
@@ -8,7 +8,9 @@
 
 export * from './types.js';
 export { parseJsx, interpretBrace } from './parse.js';
-export { validateTree } from './validate.js';
+export { HTML_TIER_NODE, isHtmlTierNode, markHtmlTierNode } from './provenance.js';
+export { validateTree, acceptsChildren, CHILD_LIST_KEY, SDUI_BASE_PROPS } from './validate.js';
+export type { SduiBaseProp, SduiBasePropScope } from './validate.js';
 export {
   checkDashboardWidgetOptions,
   CONSUMED_WIDGET_OPTION_KEYS,
@@ -18,17 +20,18 @@ export {
 export { generateDts, propsName, generateBlockList } from './codegen.js';
 export type { CodegenOptions } from './codegen.js';
 export { inputTypeArms, canonicalizeInputType, MANIFEST_INPUT_TYPES } from './input-type.js';
+export { checkRetiredBodyDialect, RETIRED_CHILD_LIST_KEY } from './body-dialect.js';
 
 import { parseJsx } from './parse.js';
 import { validateTree } from './validate.js';
 import { canonicalizeInputType } from './input-type.js';
-import type { Diagnostic, Manifest, SchemaElement, ValidationResult } from './types.js';
+import type { Diagnostic, Manifest, SchemaElement, ManifestValidationResult } from './types.js';
 
 export interface CompileResult {
   tree: SchemaElement | null;
   diagnostics: Diagnostic[];
   requires: string[];
-  bindings: ValidationResult['bindings'];
+  bindings: ManifestValidationResult['bindings'];
   /** true when there are no error-severity diagnostics — the save gate's pass/fail */
   ok: boolean;
 }
@@ -58,9 +61,26 @@ export function compile(source: string, manifest: Manifest): CompileResult {
  * the `tier:'public'` set).
  * ------------------------------------------------------------------ */
 
+/**
+ * The shape of one `@object-ui/types` `NodeSlotDeclaration`, restated
+ * structurally because this package imports nothing at runtime: a position in
+ * that package's key-path grammar, and whether its spelling is retired.
+ */
+export interface NodeSlotDeclarationLike {
+  readonly path: string;
+  readonly retired?: boolean;
+}
+
 export interface RegistryConfigLike {
   type: string;
   namespace?: string;
+  /**
+   * LAYOUT containment — the registration's `ComponentMeta.isContainer`,
+   * carried through to the manifest for the consumers that read it there.
+   * ⛔ It does not mean "accepts children" and `validateTree` does not read
+   * it: whether a component takes an authored child list is declared as an
+   * input named `children` (objectui#9910; `acceptsChildren` in `validate.ts`).
+   */
   isContainer?: boolean;
   /**
    * ADR-0080 contract tier — only 'public' configs form the AI/contract
@@ -112,6 +132,38 @@ export interface RegistryConfigLike {
     binding?: 'object';
     description?: string;
   }>;
+  /**
+   * True when the registry entry is a pending lazy stub — registered, but its
+   * plugin module has not been imported, so it carries metadata and no
+   * `inputs`. See {@link assertFullyLoaded}.
+   */
+  lazy?: boolean;
+}
+
+/**
+ * Build-time guard for the manifest generators.
+ *
+ * A manifest is the contract's frozen form: the parser's tag whitelist and the
+ * save gate's prop validator both read it. So it has to be generated from
+ * FULLY LOADED registrations. A `lazy: true` entry means the generator never
+ * imported that plugin, and the block would be written out with empty
+ * `inputs` — indistinguishable from a block that legitimately takes no props,
+ * which turns every prop an author writes on it into an `unknown-prop`
+ * diagnostic. Wrong quietly, in the artifact everything downstream trusts.
+ *
+ * The generators keep their own eager import list, so this is what catches it
+ * drifting behind the app's registration list (objectui#2953 was the same
+ * class of bug one layer down).
+ */
+export function assertFullyLoaded(configs: RegistryConfigLike[]): void {
+  const stubs = configs.filter((c) => c.lazy).map((c) => c.type).sort();
+  if (stubs.length === 0) return;
+  throw new Error(
+    `Manifest generation saw ${stubs.length} not-yet-loaded lazy block(s): ${stubs.join(', ')}.\n` +
+      `A manifest must describe loaded registrations — these would be written out with no \`inputs\`, ` +
+      `so every prop an author passes them would be reported as unknown.\n` +
+      `Add an eager \`import\` of each block's plugin to the generator entry.`,
+  );
 }
 
 /* The arm vocabulary and the two projections over it now live in
@@ -119,18 +171,58 @@ export interface RegistryConfigLike {
  * all read `ManifestInput.type` and must agree on how, since it holds one arm
  * or an array of them (objectui#3832). */
 
+/**
+ * Project registry configs into the SDUI manifest.
+ *
+ * ⚠️ Every field here is copied from what the registration **declared**. In
+ * particular `inputs` is `config.inputs` verbatim — this function does not, and
+ * cannot, observe whether the renderer behind the block reads any of them.
+ *
+ * Worth stating because of what consumes the output. The framework's
+ * `check:react-blocks-declaration-parity` diffs this against the spec's zod
+ * schemas, and while that check was named `check:react-conformance` it was read
+ * — by its own file header — as confirming the components "ACTUALLY implement"
+ * the spec's props. It never could: both sides of that diff are declarations,
+ * and this is the side this file produces. Four blocks published an `objectName`
+ * no renderer read and sailed through it green (objectstack#4413; corrected in
+ * objectstack#4472). Evidence about the render path has to come from the render
+ * path — see `ui/apps/console/src/__tests__/public-block-binding-reach.test.tsx`.
+ *
+ * `opts.slotsFor` is the one exception to "copied from the registration", and
+ * it is a DECLARATION too (objectui#11170): hand it `nodeSlotsFor` from
+ * `@object-ui/types` and every entry carries `slots`, the node-slot positions
+ * that type's renderer reads besides `children`, so `validateTree` judges the
+ * nodes under them. This package has no runtime dependency and so cannot
+ * import the declaration itself; the producers that build a live manifest
+ * (`getJsxManifest` in `@object-ui/components`' page renderer, the console's
+ * manifest generator) pass it. A RETIRED position is left out here: this is
+ * the authoring tier, and the spec's own authoring walks skip the tombstoned
+ * spellings for the same reason. Without the option no `slots` key is written,
+ * so every manifest built before the option existed serialises byte-identically.
+ */
 export function manifestFromConfigs(
   configs: RegistryConfigLike[],
-  opts: { only?: Set<string>; publicOnly?: boolean } = {},
+  opts: {
+    only?: Set<string>;
+    publicOnly?: boolean;
+    slotsFor?: (type: string) => readonly NodeSlotDeclarationLike[];
+  } = {},
 ): Manifest {
   const components: Manifest['components'] = {};
   for (const c of configs) {
     if (opts.only && !opts.only.has(c.type)) continue;
     if (opts.publicOnly && c.tier !== 'public') continue;
+    const slots = opts.slotsFor
+      ? opts.slotsFor(c.type).filter((s) => !s.retired).map((s) => s.path)
+      : undefined;
     components[c.type] = {
       type: c.type,
       namespace: c.namespace,
       isContainer: c.isContainer,
+      // `undefined` is dropped by `JSON.stringify`, so a manifest built with
+      // no resolver — or an entry with no slots — serialises exactly as before
+      // this key existed.
+      slots: slots && slots.length > 0 ? slots : undefined,
       // The html tier's stamp, and ONLY that stamp (objectui#10735): a
       // registration's `'public'` / `'internal'` is registry mechanics the
       // manifest never carried, and `undefined` is dropped by `JSON.stringify`,
diff --git a/packages/sdui-parser/src/parse.ts b/packages/sdui-parser/src/parse.ts
index d44c113e157..4268ae545e3 100644
--- a/packages/sdui-parser/src/parse.ts
+++ b/packages/sdui-parser/src/parse.ts
@@ -4,7 +4,7 @@
  * A small recursive-descent parser for a CONSTRAINED JSX subset. It is
  * deliberately not a full JS/JSX parser: a bounded grammar is the point
  * (Markdoc model) — it shrinks the attack surface and the expressible-but-wrong
- * space. Output is the existing SDUI `SchemaNode` tree. Nothing is executed.
+ * space. Output is an SDUI node tree (`ParsedSchemaNode`). Nothing is executed.
  *
  * Grammar (informal):
  *   document := element                       (exactly one root)
@@ -14,7 +14,8 @@
  *   tag      := [A-Za-z][A-Za-z0-9:_-]star      (matches registry keys)
  */
 
-import type { Diagnostic, ParseOptions, ParseResult, SchemaElement, SchemaNode } from './types.js';
+import type { Diagnostic, ParseOptions, ParseResult, SchemaElement, ParsedSchemaNode } from './types.js';
+import { markHtmlTierNode } from './provenance.js';
 
 /** Event handlers and raw-HTML injection are never allowed (parse ≠ execute). */
 const EVENT_ATTR = /^on[A-Z]/;
@@ -45,12 +46,12 @@ const FORBIDDEN_ATTRS = new Set(['dangerouslySetInnerHTML', 'ref', 'key']);
  * member), so removing it there would make every legitimate node warn. The
  * refusal belongs here, at parse.
  *
- * ⚠️ The code is the EXISTING `forbidden-attr`, not a new one, and that is
- * load-bearing rather than lazy: `scripts/check-sdui-lockstep.mjs` holds this
- * copy's diagnostic-code set equal to objectui's at the pinned revision, so a
- * code minted on one side only IS the dialect split that gate exists to catch
- * (#12719). `forbidden-attr` already carries this shape — an attribute this
- * tier refuses, named beside its element — and both copies stamp it.
+ * ⚠️ The code is the EXISTING `forbidden-attr`, not a new one. While the save
+ * gate and the renderer ran separate copies of this parser, a code minted on
+ * one side only was the dialect split #12719 describes; one copy remains
+ * (#25712), and the reason that outlives the split is the shape:
+ * `forbidden-attr` already carries it — an attribute this tier refuses, named
+ * beside its element.
  */
 const DISCRIMINATOR_ATTR = 'type';
 
@@ -115,7 +116,7 @@ class Parser {
     }
 
     this.skipWs();
-    let children: SchemaNode[] | undefined;
+    let children: ParsedSchemaNode[] | undefined;
     if (this.eat('/')) {
       if (!this.eat('>')) this.error('bad-self-close', `Malformed self-closing <${tag}>`, this.pos, tag);
     } else if (this.eat('>')) {
@@ -124,6 +125,14 @@ class Parser {
       this.error('unterminated-open-tag', `Unterminated <${tag}> open tag`, start, tag);
     }
 
+    // Stamp html-tier provenance at the point of production (objectui#4000).
+    // Renderers whose type carries authoring advice aimed at the JSON surface
+    // read this to tell "the author wrote a tag in OUR tier, and there is no
+    // other spelling available to them" apart from "the author wrote this type
+    // in JSON, where the advice applies". Symbol-keyed, so it is invisible to
+    // JSON, to the DOM, and to anything an authored document could forge — see
+    // provenance.ts. Values reached through a braced attribute are NOT marked:
+    // that JSON was written by hand, and the JSON surface's advice does apply.
     // DEFENSE IN DEPTH (ruled together with the refusal above). `props` used to
     // be spread AFTER `type: tag`, so an authored `type` attribute overwrote the
     // discriminator the tag established and nothing downstream restored it —
@@ -134,7 +143,12 @@ class Parser {
     // regression of its own — the authored value would then be dropped in
     // silence, trading one silence for another. It is correct only BECAUSE the
     // attribute is refused loudly one function up.
-    const node: SchemaElement = { ...props, type: tag };
+    //
+    // ⚠️ The `markHtmlTierNode` wrapper survives the reversal: it stamps the
+    // object the spread produced, so the marker is applied after every key is
+    // in place regardless of their order. Pinned in provenance.test.ts, because
+    // this is the one edit that could drop it.
+    const node: SchemaElement = markHtmlTierNode({ ...props, type: tag });
     if (children && children.length) node.children = children;
     return node;
   }
@@ -181,8 +195,8 @@ class Parser {
     return undefined;
   }
 
-  private parseChildren(parentTag: string): SchemaNode[] {
-    const children: SchemaNode[] = [];
+  private parseChildren(parentTag: string): ParsedSchemaNode[] {
+    const children: ParsedSchemaNode[] = [];
     for (;;) {
       if (this.pos >= this.src.length) {
         this.error('unclosed-element', `Unclosed <${parentTag}>`, this.pos, parentTag);
@@ -233,15 +247,14 @@ class Parser {
       // HTML collapses a whitespace run to ONE space; it does not delete it. A
       // bare `.trim()` here deleted the space that separates a text run from an
       // adjacent sibling element, so `A <strong>x</strong> page` compiled to
-      // `A`/`page` and the words ran together wherever the tree is rendered.
-      // The rule (triage option (b), shared verbatim with the downstream copy
-      // of this parser so the two agree): collapse the run, then keep a single
-      // leading space only when a sibling precedes the run, and a single
-      // trailing space only when a sibling element follows it. At the parent's
-      // own start/end the edge space is still dropped, so `<p>  hi  </p>` stays
-      // `hi`. A whitespace-only run survives as one space only when it sits
-      // BETWEEN siblings — that is the bounded over-generosity of this rule
-      // inside block containers like `<ul>`, pinned in the tests.
+      // `A`/`page` and rendered as `Axpage` (objectui#5661). The rule: collapse
+      // the run, then keep a single leading space only when a sibling precedes
+      // the run, and a single trailing space only when a sibling element
+      // follows it. At the parent's own start/end the edge space is still
+      // dropped, so `<p>  hi  </p>` stays `hi`. A whitespace-only run survives
+      // as one space only when it sits BETWEEN siblings — that is the bounded
+      // over-generosity of this rule inside block containers like `<ul>`,
+      // pinned in the tests.
       const text = this.readTextRun();
       const collapsed = text.replace(/\s+/g, ' ');
       const core = collapsed.trim();
@@ -357,13 +370,6 @@ class Parser {
  * subset existed. The reader below only ever sees strings `JSON.parse` has
  * already thrown on, which makes strict-JSON invariance a property of the
  * structure rather than of a test.
- *
- * LOCKSTEP: this grammar is the port of objectui's `packages/sdui-parser` copy
- * (objectui#6614). The two copies must agree on the accepted grammar AND on
- * diagnostic codes — if they drift, the save gate and the renderer speak
- * different dialects and a page can save clean and render inert
- * (objectstack#12719 states the invariant; #12977 carries this half of it).
- * Change this block only together with the objectui copy.
  */
 export function interpretBrace(raw: string): unknown {
   const trimmed = raw.trim();
diff --git a/packages/sdui-parser/src/provenance.ts b/packages/sdui-parser/src/provenance.ts
new file mode 100644
index 00000000000..c6850a05040
--- /dev/null
+++ b/packages/sdui-parser/src/provenance.ts
@@ -0,0 +1,92 @@
+/*! Moved into @objectstack/sdui-parser from @object-ui/sdui-parser
+ * (objectstack#25712); this file keeps the licence it was written under.
+ * MIT License. Copyright (c) 2024 ObjectQL. The full permission notice ships
+ * as LICENSE-MIT beside this package's manifest. */
+
+/**
+ * ObjectUI — html-tier provenance (ADR-0080, objectui#4000)
+ *
+ * Records the one fact a renderer cannot otherwise recover: whether the node it
+ * is about to render was EMITTED BY THIS PARSER (an author's `kind:'html'`
+ * source, compiled tag-name-straight-through) or AUTHORED AS JSON metadata.
+ *
+ * Why a renderer needs it: the two surfaces have different vocabularies. A type
+ * the JSON surface is steering authors away from can still be a supported tag
+ * in the html tier — the plain inline element (`span`) is exactly that. (The
+ * plain box element was too, until objectui#10757 deprecated `div` on the html
+ * surface as well; the console's html compile now refuses it outright, so no
+ * notice is involved there.) Advice aimed at the JSON surface, delivered to an
+ * html-tier author, is advice they cannot act on: in that tier there is no
+ * other spelling. The
+ * deprecation notice fired at them anyway (objectui#4000), which is also why the
+ * type could never be retired — the engine's own compiler keeps emitting it.
+ *
+ * The judgement therefore has to be PROVENANCE, established by the producer,
+ * not a guess made at the consumer from the node's shape.
+ *
+ * ## Why a symbol, and why `Symbol.for`
+ *
+ * The marker is deliberately NOT a JSON-visible key:
+ *
+ *  - `JSON.stringify` skips symbol keys, so provenance never lands in a
+ *    persisted tree. That is the point, not a limitation: "our parser produced
+ *    this node in this process" is not a fact about the saved document, and a
+ *    saved document must not be able to REPLAY it. A string key like
+ *    `_provenance: 'html'` would be copyable — an authored (or AI-generated)
+ *    JSON page could paste it in and buy itself silence from a notice that is
+ *    meant for it. Provenance that authored metadata can forge is not
+ *    provenance.
+ *  - `Object.keys` / `for...in` skip symbol keys, so the marker cannot leak out
+ *    of a renderer onto a host element as a stray DOM attribute.
+ *
+ * It IS enumerable, which matters more than it looks: `SchemaRenderer` hands
+ * renderers a shallow copy of the node (`{ ...schema }`), and object spread
+ * copies own ENUMERABLE symbol keys while dropping non-enumerable ones. A
+ * non-enumerable marker would be lost in that copy and the misfire would come
+ * back — silently, and only in the render path. `render.test.tsx` and the
+ * components-side pin both go through the real `SchemaRenderer` for this reason.
+ *
+ * `Symbol.for` (the cross-realm registry) rather than a module-local `Symbol()`:
+ * this package ships as both ESM and CJS and is consumed from several packages,
+ * so two module instances are possible. Two local symbols would not compare
+ * equal, and the failure mode of that mismatch is the ORIGINAL BUG returning
+ * with no error anywhere. A registry key cannot drift.
+ */
+
+/**
+ * Registry key for the marker. Stable — it is a cross-instance contract, so it
+ * keeps the package name it was minted under: a node stamped by an older
+ * `@object-ui/sdui-parser` still reads as html-tier here, and the reverse.
+ */
+const HTML_TIER_NODE_KEY = '@object-ui/sdui-parser.html-tier-node';
+
+/**
+ * The provenance marker itself. Exported for tests and for any consumer that
+ * needs to reason about the key; prefer {@link isHtmlTierNode} for reading.
+ */
+export const HTML_TIER_NODE: symbol = Symbol.for(HTML_TIER_NODE_KEY);
+
+/**
+ * Stamp a node as html-tier output. Called by the parser as it builds each
+ * element — the producer is the only place that knows this for certain.
+ */
+export function markHtmlTierNode<T extends object>(node: T): T {
+  (node as Record<symbol, unknown>)[HTML_TIER_NODE] = true;
+  return node;
+}
+
+/**
+ * True when this node came out of the html tier's parser.
+ *
+ * Deliberately a plain boolean read of the marker — no fallback to a
+ * string-keyed spelling, no shape heuristic ("looks like a raw tag"). Either
+ * the producer marked it or it did not; a consumer-side guess is precisely what
+ * this replaces.
+ */
+export function isHtmlTierNode(node: unknown): boolean {
+  return (
+    typeof node === 'object' &&
+    node !== null &&
+    (node as Record<symbol, unknown>)[HTML_TIER_NODE] === true
+  );
+}
diff --git a/packages/sdui-parser/src/types.ts b/packages/sdui-parser/src/types.ts
index cd37a78c654..84a9c718c49 100644
--- a/packages/sdui-parser/src/types.ts
+++ b/packages/sdui-parser/src/types.ts
@@ -2,16 +2,32 @@
  * ObjectUI — SDUI JSX-source parser (ADR-0080)
  *
  * Types shared by the constrained JSX-source compiler. The parser turns a
- * constrained JSX/HTML+Tailwind *text* into the existing SDUI `SchemaNode`
- * tree. It PARSES — it never executes. No `import`, no `eval`, no JS.
+ * constrained JSX *text* into an SDUI node tree (`ParsedSchemaNode`, below).
+ * It PARSES — it never executes. No `import`, no `eval`, no JS.
  */
 
-/** A node in the compiled SDUI tree. Mirrors `@object-ui/types` BaseSchema. */
-export type SchemaNode = SchemaElement | string;
+/**
+ * A node in the compiled SDUI tree, as parsed: an element or a text child.
+ *
+ * Not `SchemaNode`: `@object-ui/types` publishes that name for the closed
+ * AUTHORING face, a union discriminated on a literal `type` with no index
+ * signature and with primitive children admitted. This is the parser's open,
+ * as-parsed data (any `type` string, the keys as authored), neither is
+ * assignable to the other, and this package takes no runtime dependency on
+ * `@object-ui/types` to re-export from. One exported name stood for both until
+ * this declaration was renamed (objectui#6349, batch 11).
+ */
+export type ParsedSchemaNode = SchemaElement | string;
+
+/**
+ * @deprecated Renamed {@link ParsedSchemaNode}; this alias keeps the name the
+ * package published before the two parser copies became one (objectstack#25712).
+ */
+export type SchemaNode = ParsedSchemaNode;
 
 export interface SchemaElement {
   type: string;
-  children?: SchemaNode[];
+  children?: ParsedSchemaNode[];
   [prop: string]: unknown;
 }
 
@@ -91,11 +107,6 @@ export interface ManifestInput {
    * Read the arms through `inputTypeArms(input.of)` — the same accessor
    * `type`'s arms go through, since the two fields carry the same shape and a
    * reader that forgets the array form is silently inert on it.
-   *
-   * LOCKSTEP: this key and its three readers — `validateTree`'s member check,
-   * `manifestFromConfigs`' canonicalization and the codegen's element type —
-   * are the port of objectui's copy. The two copies must agree on the accepted
-   * grammar AND on diagnostic codes; change this only together with objectui.
    */
   of?: ManifestInputType | ManifestInputType[];
   required?: boolean;
@@ -128,7 +139,7 @@ export interface ManifestInput {
    *      in `index.ts`. A union wider than the producer's is imprecision on
    *      the way out, not permissiveness on the way in.
    *   2. **Its sibling is a pure producer face.**
-   *      {@link ValidationResult.bindings}`[].kind` is written by
+   *      {@link ManifestValidationResult.bindings}`[].kind` is written by
    *      `validateTree` by copying this key, so the subset relation runs the
    *      other way there — see that declaration. The two are COUPLED by that
    *      assignment: narrowing one alone needs a cast at the only conversion
@@ -166,6 +177,19 @@ export interface ManifestComponent {
    * carry no such entry (objectui#9910; `acceptsChildren` in `validate.ts`).
    */
   inputs: ManifestInput[];
+  /**
+   * The NODE SLOTS this component's renderer reads besides `children`
+   * (objectui#11170): positions in the key-path grammar `@object-ui/types`'
+   * `NODE_SLOT_DECLARATIONS` states — `trigger`, `items[].content`,
+   * `regions[].components`. `validateTree` descends each one the way it
+   * descends `children`, so a slot-held node is judged too. Projected from
+   * that one declaration by `manifestFromConfigs`'s `slotsFor` option; the
+   * authoring tier leaves the declaration's RETIRED positions out, as the
+   * spec's own authoring walks do. ⛔ This tier keeps no slot list of its own:
+   * a manifest built without the option carries none, and the walk then
+   * follows `children` alone.
+   */
+  slots?: readonly string[];
   /**
    * LAYOUT containment (objectui#6804, objectui#9910 Q2-A): the flag the
    * react-page JSX scope builder skips and the public layout ledger lists.
@@ -196,8 +220,23 @@ export interface Manifest {
   components: Record<string, ManifestComponent>;
 }
 
-/** Result of validating a compiled tree against the manifest. */
-export interface ValidationResult {
+/**
+ * Result of validating a compiled tree against the MANIFEST.
+ *
+ * Named `ManifestValidationResult`, not `ValidationResult` (objectui#3161,
+ * objectstack#4115 ledger batch 7), following the convention registered on
+ * objectstack#4115 for this name: **`<what was validated>Validation<Error |
+ * Result>`**. `ValidationResult` is exported twice by the spec — `kernel` and
+ * `contracts`, both `{ valid, errors?: [{ field, message, code? }], warnings? }`
+ * for PLUGIN MANIFEST validation — and `@object-ui/core` took
+ * `SchemaNodeValidationResult` under the same convention in batch 4
+ * (objectui#3188). Three results, three subjects: a plugin, a schema node, and
+ * this one, which carries no `valid` flag at all — it returns `diagnostics`
+ * (severity lives per entry), the `requires` set the compiled page needs, and
+ * the binding sites the server must resolve. Nothing here is assignable to
+ * anything there in either direction.
+ */
+export interface ManifestValidationResult {
   diagnostics: Diagnostic[];
   /** unique plugin namespaces referenced — the page's `requires` */
   requires: string[];
@@ -214,3 +253,10 @@ export interface ValidationResult {
    */
   bindings: Array<{ tag: string; input: string; kind: 'object'; value: unknown }>;
 }
+
+/**
+ * @deprecated Renamed {@link ManifestValidationResult}; this alias keeps the
+ * name the package published before the two parser copies became one
+ * (objectstack#25712).
+ */
+export type ValidationResult = ManifestValidationResult;
diff --git a/packages/sdui-parser/src/validate.ts b/packages/sdui-parser/src/validate.ts
index 86cc578493a..d3db63bd18f 100644
--- a/packages/sdui-parser/src/validate.ts
+++ b/packages/sdui-parser/src/validate.ts
@@ -8,6 +8,13 @@
  * `requires` (plugin provenance) and binding sites the SERVER must resolve
  * against object schema (we cannot resolve objects/fields here — that check is
  * framework-side by design).
+ *
+ * The walk descends `children` on every node and, for a component the
+ * manifest knows, the NODE SLOTS its entry carries (`ManifestComponent.slots`,
+ * objectui#11170) — the positions besides `children` through which that
+ * renderer hands nodes back to `SchemaRenderer`, projected from the one
+ * declaration in `@object-ui/types` by `manifestFromConfigs`. ⛔ No slot list
+ * lives here.
  */
 
 import type {
@@ -17,11 +24,12 @@ import type {
   ManifestInput,
   ManifestInputType,
   SchemaElement,
-  SchemaNode,
-  ValidationResult,
+  ParsedSchemaNode,
+  ManifestValidationResult,
 } from './types.js';
 import { inputTypeArms } from './input-type.js';
 import { checkDashboardWidgetOptions } from './dashboard-widget-options.js';
+import { checkRetiredBodyDialect } from './body-dialect.js';
 
 /**
  * The protocol's ONE child-list key — `BaseSchema.children` — and therefore the
@@ -34,25 +42,23 @@ export const CHILD_LIST_KEY = 'children';
  * Does this component ACCEPT an authored child list? (objectui#9910)
  *
  * Read from exactly ONE declaration: an input named {@link CHILD_LIST_KEY} in
- * the component's `inputs`, whatever its coarse type — the page kinds publish
- * it typed `array`, the rest typed `slot`, and the NAME is the declaration.
- * objectui's registry census holds that declaration true in both directions
- * (a renderer that puts `schema.children` on the page declares it; a
- * declaration whose renderer never renders the list is red).
- *
- * ⛔ `isContainer` is NOT consulted and is NOT a fallback. The flag now means
- * LAYOUT containment only (objectui#9910 Q2-A) and it disagrees with the
- * declared input both ways in the served manifest: `badge` / `alert` /
- * `button` declare the slot with the flag off, `page:tabs` /
- * `page:accordion` carry the flag with no slot.
+ * the component's `inputs`. That is the shape ten registrations already
+ * carried when the maintainer ruled it the containment contract
+ * (2026-09-24, objectui#9910 Q1-A "declare-and-pin"), and it is held in both
+ * directions by the runtime census in
+ * `ui/packages/components/src/renderers/__tests__/container-declaration-ratchet.test.tsx`:
+ * a renderer that puts `schema.children` on the page without declaring the
+ * input is red, and a declaration whose renderer never renders the list is
+ * red too.
  *
- * LOCKSTEP: this function, {@link CHILD_LIST_KEY} and the containment branch
- * in `validateTree` are the byte-equal port of objectui's copy (objectui
- * `packages/sdui-parser/src/validate.ts`, objectui#9910 re-cut `5ea623ea`),
- * so the save gate and the renderer reach the same `not-a-container` verdict
- * on every page (#12719). `pnpm check:sdui-lockstep` compares this predicate
- * against the vendored record of objectui's and goes red when they diverge
- * (#19969) — change it only together with objectui.
+ * ⛔ `isContainer` is NOT consulted and is NOT a fallback. It used to decide
+ * this branch and it lied both ways: a hand-kept flag drifted from the code
+ * (objectui#3900 / `7c9b044f4` / #6764 / #6779 found the same drift four times),
+ * and after objectui#6771 converged a dozen registrations onto `children`
+ * the flag put a FALSE `not-a-container` on the one key they read
+ * (objectui#9910). The flag now means LAYOUT containment only — the
+ * react-page JSX scope and the public layout ledger read it; this tier does
+ * not (objectui#6804, objectui#9910 Q2-A).
  */
 export function acceptsChildren(comp: Pick<ManifestComponent, 'inputs'>): boolean {
   return comp.inputs.some((input) => input.name === CHILD_LIST_KEY);
@@ -129,12 +135,6 @@ export interface SduiBaseProp {
  * second permanent spelling of one concept. `./body-dialect.ts` answers it by
  * name instead.
  *
- * LOCKSTEP: the list, its scopes and the two Sets below are the port of
- * objectui's `SDUI_BASE_PROPS` (objectui#11008, #11044, pin `db11afd4967c`).
- * Both consumers are ported too: {@link validateTree} and `codegen.ts`'s
- * `SduiBaseProps`. The list is exported for `codegen.ts` only; `index.ts` does
- * not re-export it.
- *
  * `children` IS here: the key is legal on every node, so it never draws
  * `unknown-prop` and its declared `slot` input is never type-checked. Whether
  * a given component RENDERS it is the containment question below, answered by
@@ -179,12 +179,53 @@ const WHERE_UNDECLARED_BASE_PROPS = basePropNames('where-undeclared');
 const isExpr = (v: unknown): boolean =>
   typeof v === 'object' && v !== null && '$expr' in (v as Record<string, unknown>);
 
-export function validateTree(tree: SchemaElement | null, manifest: Manifest): ValidationResult {
+const isPlainObject = (v: unknown): v is Record<string, unknown> =>
+  typeof v === 'object' && v !== null && !Array.isArray(v);
+
+const isElement = (v: unknown): v is SchemaElement =>
+  isPlainObject(v) && typeof v.type === 'string';
+
+/**
+ * The element nodes a slot position holds on `node`, in document order.
+ *
+ * The position is spelled in `@object-ui/types`' key-path grammar, which that
+ * package's `nodeSlotValues` implements for the other two readers and whose
+ * header states it: keys separated by `.`, a key followed by `[]` meaning each
+ * element of the array under it, and the value at the end being one node or a
+ * list of nodes. Restated here because this package imports nothing at
+ * runtime; the components-side census for objectui#11170 holds the two walks
+ * to the same answer over the same fixtures. Only element-shaped values are
+ * returned — a string child is legal in a slot and has nothing to validate.
+ */
+function slotElements(node: SchemaElement, path: string): SchemaElement[] {
+  let holders: unknown[] = [node];
+  for (const segment of path.split('.')) {
+    const each = segment.endsWith('[]');
+    const key = each ? segment.slice(0, -2) : segment;
+    const next: unknown[] = [];
+    for (const holder of holders) {
+      if (!isPlainObject(holder)) continue;
+      const value = holder[key];
+      if (!each) next.push(value);
+      else if (Array.isArray(value)) next.push(...value);
+    }
+    holders = next;
+  }
+  const found: SchemaElement[] = [];
+  for (const holder of holders) {
+    for (const value of Array.isArray(holder) ? holder : [holder]) {
+      if (isElement(value)) found.push(value);
+    }
+  }
+  return found;
+}
+
+export function validateTree(tree: SchemaElement | null, manifest: Manifest): ManifestValidationResult {
   const diagnostics: Diagnostic[] = [];
   const requires = new Set<string>();
-  const bindings: ValidationResult['bindings'] = [];
+  const bindings: ManifestValidationResult['bindings'] = [];
 
-  const visit = (node: SchemaNode): void => {
+  const visit = (node: ParsedSchemaNode): void => {
     if (typeof node === 'string') return;
     const comp = manifest.components[node.type];
     if (!comp) {
@@ -219,12 +260,23 @@ export function validateTree(tree: SchemaElement | null, manifest: Manifest): Va
         if (WHERE_UNDECLARED_BASE_PROPS.has(key) && !byName.has(key)) continue;
         const input = byName.get(key);
         if (!input) {
-          diagnostics.push({
-            severity: 'warning',
-            code: 'unknown-prop',
-            message: `<${node.type}> has no prop "${key}"`,
-            tag: node.type,
-          });
+          // The retired `body` child-list dialect gets its replacement named
+          // rather than the bare "has no prop" every typo gets
+          // (objectui#6771). Asked INSIDE this branch, so a component that
+          // declares its own `body` input keeps its declared type check —
+          // mechanism in `./body-dialect.ts`. Its containment verdict is the
+          // SAME predicate the `children` branch below reads — the declared
+          // `children` input, never `isContainer` (objectui#9910) — so the two
+          // spellings cannot disagree about which components take a list.
+          const retiredBody = checkRetiredBodyDialect(node.type, key, value, acceptsChildren(comp));
+          diagnostics.push(
+            retiredBody ?? {
+              severity: 'warning',
+              code: 'unknown-prop',
+              message: `<${node.type}> has no prop "${key}"`,
+              tag: node.type,
+            },
+          );
           continue;
         }
         if (input.binding) {
@@ -257,14 +309,6 @@ export function validateTree(tree: SchemaElement | null, manifest: Manifest): Va
           // deliberately NOT part of this change: it belongs at the SAVE GATE,
           // once the framework wires the registry manifest into
           // `validate-jsx-pages` (#12719 records that gap).
-          //
-          // LOCKSTEP: this diagnostic is the byte-equal port of objectui's
-          // `packages/sdui-parser` copy (objectui#6613, message reworded by
-          // objectui#6614). The two copies must agree on the accepted grammar
-          // AND on diagnostic codes — if they drift, the save gate and the
-          // renderer speak different dialects and a page can save clean and
-          // render inert. Change this block only together with the objectui
-          // copy.
           diagnostics.push({
             severity: 'warning',
             code: 'inert-expression',
@@ -309,35 +353,30 @@ export function validateTree(tree: SchemaElement | null, manifest: Manifest): Va
       // `./dashboard-widget-options.ts`). Like `not-a-container`, this runs
       // only for a component the manifest knows: an unresolved tag already
       // drew `unknown-component`, and deep diagnostics on it would be noise.
-      //
-      // LOCKSTEP: this call site and the module behind it are the byte-equal
-      // port of objectui's copy (objectstack#12810). The two copies must agree
-      // on the accepted grammar AND on diagnostic codes — if they drift, the
-      // save gate and the renderer speak different dialects and a page can save
-      // clean and render inert. Change this only together with objectui.
       diagnostics.push(...checkDashboardWidgetOptions(node));
     }
 
     if (node.children) node.children.forEach(visit);
+    // The node slots this component's renderer reads besides `children`
+    // (objectui#11170), as its manifest entry declares them. An unknown
+    // component has no entry and so no slots: its `unknown-component` above is
+    // the answer, and nothing under it is judged.
+    for (const path of comp?.slots ?? []) {
+      for (const element of slotElements(node, path)) visit(element);
+    }
   };
 
   if (tree) visit(tree);
   return { diagnostics, requires: [...requires], bindings };
 }
 
-/* LOCKSTEP: everything below this line is the byte-equal port of objectui's
- * `packages/sdui-parser` coarse type check (objectui#3832 — union-typed inputs
- * are checked over their arms — and objectui#8067, the same check one level
- * down over the member kind `of` declares). The two copies must agree on the accepted
- * grammar AND on diagnostic codes/severities — if they drift, the save gate
- * and the renderer speak different dialects. Change these functions only
- * together with the objectui copy.
- *
- * Known lead: this copy grades every `type-mismatch` and `member-type-mismatch`
- * `error` (a literal's coarse type is certain; see `checkType`). objectui's
- * copy, `packages/sdui-parser/src/validate.ts` at the `.objectui-sha` pin,
- * still grades them `error` only when an `enum` arm is present. Codes and
- * messages agree; the severity differs until objectui ports the same rule. */
+/* The coarse type check: a union-typed input is checked over its arms
+ * (objectui#3832), and the same check runs one level down over the member kind
+ * `of` declares (objectui#8067). Every `type-mismatch` and `member-type-mismatch`
+ * is an `error`, because a literal's coarse type is certain (see `checkType`).
+ * The renderer's former copy of this package graded them `error` only beside an
+ * `enum` arm; this rule is the one that stayed when the two copies became one
+ * (#25712). */
 
 /** The values an `enum` arm admits, flattened from either declaration form. */
 const enumValues = (input: ManifestInput): unknown[] =>
diff --git a/packages/spec/src/ui/visibility-alias-keys-retirement.test.ts b/packages/spec/src/ui/visibility-alias-keys-retirement.test.ts
index fcb9e726557..81a32795efb 100644
--- a/packages/spec/src/ui/visibility-alias-keys-retirement.test.ts
+++ b/packages/spec/src/ui/visibility-alias-keys-retirement.test.ts
@@ -250,6 +250,10 @@ describe('tree-scoped absence: nothing inside the declared radius still authors
     'packages/spec/src/ui/component.test.ts',
     // The view write door's generic moved-key projection, modelled on the old fold.
     'packages/metadata-protocol/src/protocol.project-storable-view-body.test.ts',
+    // The SDUI parser tier's base-prop list (`SDUI_BASE_PROPS`) still accepts the
+    // deprecated `visibleOn` on every node; this pin gives each member a
+    // well-typed value (moved in from the renderer's copy by #25712).
+    'packages/sdui-parser/src/__tests__/base-props-one-list-11044.test.ts',
   ]);
   const EXCLUDED_PREFIXES = [
     // The D2 conversions' fixtures and the stored-row replay pins author the pre-18 shapes on purpose.
diff --git a/scripts/check-published-files.mjs b/scripts/check-published-files.mjs
index 5c9c3bea6bc..67f3d2f8730 100644
--- a/scripts/check-published-files.mjs
+++ b/scripts/check-published-files.mjs
@@ -292,6 +292,10 @@ const EXTRA_ENTRIES = {
     'protocol-upgrade-guide.md':
       'The protocol upgrade guide, generated from the ADR-0087 registries at publish (it is not in the tree) so an upgrading agent reads the guide for the version it installed, offline. scripts/release-spec-changes.sh --verify refuses an artifact that ships without it.',
   },
+  '@objectstack/sdui-parser': {
+    'LICENSE-MIT':
+      'The MIT permission notice for body-dialect.ts and provenance.ts, which moved in from @object-ui/sdui-parser (#25712) and keep the licence they were written under; MIT requires the notice to travel with every copy, and the bundled dist carries only a pointer to it.',
+  },
 };
 
 // Content that must never reach a consumer, whatever admits it. Each entry is