@object-ui/sdui-parser 17.6.0 → 18.0.0

package/dist/parse.d.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)
@@ -17,8 +17,17 @@ import type { ParseOptions, ParseResult } from './types.js';
 export declare function parseJsx(source: string, options?: ParseOptions): ParseResult;
 /**
  * Interpret a braced attribute value `{...}`.
- * JSON-literal values (numbers, booleans, null, strings, arrays, objects with
- * quoted keys) are materialized. Anything else is kept as a deferred expression
- * marker `{ $expr }` — typed and validated later, NEVER evaluated here.
+ *
+ * Strict-JSON values are materialized by `JSON.parse`, exactly as they always
+ * were. Beyond that, the JS **literal subset** below is materialized too
+ * (objectui#6614 Q1-A, maintainer ruling 2026-08-28). Anything left over — a
+ * genuine expression — is kept as the deferred marker `{ $expr }`: typed and
+ * validated later, drawing `inert-expression`, and NEVER evaluated here.
+ *
+ * ORDER IS LOAD-BEARING. `JSON.parse` runs FIRST and is untouched, so every
+ * input JSON accepts takes byte-identically the path it took before the literal
+ * 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.
  */
 export declare function interpretBrace(raw: string): unknown;

package/dist/parse.js

@@ -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)
@@ -17,6 +17,47 @@ import { markHtmlTierNode } from './provenance.js';
 /** Event handlers and raw-HTML injection are never allowed (parse ≠ execute). */
 const EVENT_ATTR = /^on[A-Z]/;
 const FORBIDDEN_ATTRS = new Set(['dangerouslySetInnerHTML', 'ref', 'key']);
+/**
+ * The envelope's own discriminator, which on THIS tier the tag name sets.
+ *
+ * An authored `type=` attribute is a NAME COLLISION with it, and the parser
+ * refuses it at parse time (maintainer ruling 2026-09-01, recorded as an
+ * append-only amendment on ADR-0080 — 「响亮拒绝」, quoted verbatim there;
+ * objectui#7235 ports it to this copy, objectstack#13957 landed the other).
+ * One diagnostic naming BOTH the tag and the attribute replaces two bad
+ * outcomes:
+ *
+ *  - the value named another REGISTERED type (`<flex type="grid">`) — the tree
+ *    carried `type:'grid'`, `validateTree` found `grid` in the manifest, every
+ *    check passed, and the page rendered a grid where the author wrote a flex.
+ *    ZERO diagnostics. On the one tier whose whole premise is that unreviewed
+ *    and AI-authored source is safe to accept.
+ *  - the value named NOTHING registered (`<object-chart type="bar">`, the shape
+ *    a react-tier author carries across) — loud, but `unknown-component`
+ *    naming `"bar"` reads as a missing plugin, never as a bad prop.
+ *
+ * ⛔ NOT rescued as `specType` the way the react tier rescues it (objectui#2880):
+ * that is consumer-side tolerance, and it would spread an alias concept to a
+ * second tier. ⛔ NOT a warning grace period either — the same ruling declined
+ * a staged rollout. ⛔ And NOT fixable at the warning layer: `type` is in
+ * `validate.ts`'s `BASE_PROPS` deliberately (it is correct for every other
+ * 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: objectstack's `scripts/check-sdui-lockstep.mjs`
+ * holds ITS copy's diagnostic-code set equal to THIS one's at the pinned
+ * revision, so a code minted on one side only IS the dialect split that gate
+ * exists to catch (objectstack#12719). `forbidden-attr` already carries this
+ * shape — an attribute this tier refuses, named beside its element — and both
+ * copies stamp it.
+ *
+ * ⚠️ This copy is the RENDERER's (and the console's live edit preview); the
+ * save gate runs objectstack's. Until this landed the two differed in accepted
+ * grammar: a page objectstack refused still compiled silently while its author
+ * was typing.
+ */
+const DISCRIMINATOR_ATTR = 'type';
 export function parseJsx(source, options = {}) {
     return new Parser(source, options).parseDocument();
 }
@@ -85,7 +126,16 @@ class Parser {
             const attr = this.parseAttr(start, tag);
             if (!attr)
                 break;
-            props[attr.name] = attr.value;
+            // `drop` is set only for the refused discriminator attribute, and only so
+            // that ONE diagnostic is what the author gets. The `__forbidden_<name>`
+            // sentinel the other refusals park in `props` reaches `validateTree`,
+            // which knows no such prop and adds `unknown-prop` naming a key nobody
+            // wrote — loud, and pointing at the wrong thing, which is the species of
+            // diagnostic this whole change exists to remove. The existing sentinel
+            // behaviour is left exactly as it was for the attributes that already had
+            // it (`ref`, `key`, `dangerouslySetInnerHTML`, `on*`).
+            if (!attr.drop)
+                props[attr.name] = attr.value;
         }
         this.skipWs();
         let children;
@@ -107,7 +157,22 @@ class Parser {
         // 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.
-        const node = markHtmlTierNode({ type: tag, ...props });
+        // 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 —
+        // `compile()` returns this tree as-is and `validateTree` then looks up
+        // `manifest.components[node.type]`, i.e. the value the author wrote, not the
+        // tag they wrote. The refusal makes that overwrite unreachable; the order
+        // here makes it impossible. ⚠️ Reversing the order ALONE would have been a
+        // 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.
+        //
+        // ⚠️ The `markHtmlTierNode` wrapper is objectui-only and 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 = markHtmlTierNode({ ...props, type: tag });
         if (children && children.length)
             node.children = children;
         return node;
@@ -126,6 +191,14 @@ class Parser {
             this.skipWs();
             value = this.parseAttrValue(tag);
         }
+        if (name === DISCRIMINATOR_ATTR) {
+            // ONE diagnostic naming both the tag and the attribute — see
+            // DISCRIMINATOR_ATTR above for why it replaces both prior outcomes.
+            this.error('forbidden-attr', `Attribute "${DISCRIMINATOR_ATTR}" is not allowed on <${tag}> — on this tier the tag name IS the `
+                + `component, so <${tag}> already means type "${tag}". Delete the attribute, or write the tag of the `
+                + 'component you meant.', elStart, tag);
+            return { name, value: undefined, drop: true };
+        }
         if (EVENT_ATTR.test(name) || FORBIDDEN_ATTRS.has(name)) {
             this.error('forbidden-attr', `Attribute "${name}" is not allowed on <${tag}>`, elStart, tag);
             return { name: `__forbidden_${name}`, value: undefined };
@@ -301,9 +374,18 @@ class Parser {
 }
 /**
  * Interpret a braced attribute value `{...}`.
- * JSON-literal values (numbers, booleans, null, strings, arrays, objects with
- * quoted keys) are materialized. Anything else is kept as a deferred expression
- * marker `{ $expr }` — typed and validated later, NEVER evaluated here.
+ *
+ * Strict-JSON values are materialized by `JSON.parse`, exactly as they always
+ * were. Beyond that, the JS **literal subset** below is materialized too
+ * (objectui#6614 Q1-A, maintainer ruling 2026-08-28). Anything left over — a
+ * genuine expression — is kept as the deferred marker `{ $expr }`: typed and
+ * validated later, drawing `inert-expression`, and NEVER evaluated here.
+ *
+ * ORDER IS LOAD-BEARING. `JSON.parse` runs FIRST and is untouched, so every
+ * input JSON accepts takes byte-identically the path it took before the literal
+ * 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.
  */
 export function interpretBrace(raw) {
     const trimmed = raw.trim();
@@ -311,6 +393,242 @@ export function interpretBrace(raw) {
         return JSON.parse(trimmed);
     }
     catch {
-        return { $expr: trimmed };
+        const literal = readLiteral(trimmed);
+        return literal === NOT_LITERAL ? { $expr: trimmed } : literal;
+    }
+}
+/* ---------------------- the JS literal subset (#6614) ---------------------- */
+/**
+ * EXACTLY TWO widenings over JSON, and nothing else:
+ *
+ *   1. **single-quoted strings** — `{'name'}`, `{['name','amount']}`, and in
+ *      key position `{{'pageSize': 25}}`;
+ *   2. **unquoted identifier object keys** — `{{pageSize: 25}}`.
+ *
+ * Everything else JSON refuses is still refused and still becomes `{ $expr }`:
+ * trailing commas, comments, array holes, spreads, `undefined` / `NaN` /
+ * `Infinity`, `+1` / `.5` / `1.` / `0x1f`, template literals, and every genuine
+ * expression — identifiers, member access, calls, operators, ternaries.
+ *
+ * That list is deliberately short. This is a VALUE grammar, not an evaluator:
+ * it contains no identifier lookup and no operator, so there is nothing here to
+ * execute (ADR-0080 — this tier parses, never executes). The widening moves the
+ * spellings an author writes by habit onto the materialized side; it does not
+ * move the boundary between data and code.
+ */
+const NOT_LITERAL = Symbol('not-a-literal');
+/** JSON's whitespace set, not JS's — narrower, and one less thing to diverge. */
+const LITERAL_WS = /[ \t\n\r]/;
+const IDENT_START = /[A-Za-z_$]/;
+const IDENT_CHAR = /[A-Za-z0-9_$]/;
+/** JSON's number grammar verbatim: no leading `+`, no `.5`, no `1.`, no hex. */
+const NUMBER = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/;
+/** JSON's escape set. `\'` is added for single-quoted strings only. */
+const SIMPLE_ESCAPE = {
+    '"': '"',
+    '\\': '\\',
+    '/': '/',
+    b: '\b',
+    f: '\f',
+    n: '\n',
+    r: '\r',
+    t: '\t',
+};
+function readLiteral(src) {
+    const reader = new LiteralReader(src);
+    const value = reader.value();
+    if (value === NOT_LITERAL)
+        return NOT_LITERAL;
+    reader.ws();
+    // Trailing anything means the input was an expression that merely STARTS with
+    // a literal (`['a'] + x`, `1 + 2`). Refuse the whole input.
+    return reader.done() ? value : NOT_LITERAL;
+}
+class LiteralReader {
+    constructor(src) {
+        Object.defineProperty(this, "src", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: src
+        });
+        Object.defineProperty(this, "pos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    done() {
+        return this.pos >= this.src.length;
+    }
+    ws() {
+        while (this.pos < this.src.length && LITERAL_WS.test(this.src[this.pos]))
+            this.pos++;
+    }
+    value() {
+        this.ws();
+        const c = this.src[this.pos];
+        if (c === undefined)
+            return NOT_LITERAL;
+        if (c === '"' || c === "'")
+            return this.string(c);
+        if (c === '[')
+            return this.array();
+        if (c === '{')
+            return this.object();
+        if (this.keyword('true'))
+            return true;
+        if (this.keyword('false'))
+            return false;
+        if (this.keyword('null'))
+            return null;
+        return this.number();
+    }
+    /** A keyword only when it is not the prefix of a longer identifier. */
+    keyword(word) {
+        if (!this.src.startsWith(word, this.pos))
+            return false;
+        const after = this.src[this.pos + word.length];
+        if (after !== undefined && IDENT_CHAR.test(after))
+            return false;
+        this.pos += word.length;
+        return true;
+    }
+    number() {
+        const m = NUMBER.exec(this.src.slice(this.pos));
+        if (!m)
+            return NOT_LITERAL;
+        this.pos += m[0].length;
+        return Number(m[0]);
+    }
+    string(quote) {
+        this.pos++; // opening quote
+        let out = '';
+        for (;;) {
+            const c = this.src[this.pos];
+            if (c === undefined)
+                return NOT_LITERAL; // unterminated
+            if (c === quote) {
+                this.pos++;
+                return out;
+            }
+            if (c === '\\') {
+                const esc = this.src[this.pos + 1];
+                if (esc === undefined)
+                    return NOT_LITERAL;
+                if (esc === 'u') {
+                    const hex = this.src.slice(this.pos + 2, this.pos + 6);
+                    if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                        return NOT_LITERAL;
+                    out += String.fromCharCode(parseInt(hex, 16));
+                    this.pos += 6;
+                    continue;
+                }
+                // `\'` is legal inside a single-quoted string only — JSON's set otherwise.
+                if (esc === "'" && quote === "'") {
+                    out += "'";
+                    this.pos += 2;
+                    continue;
+                }
+                const simple = SIMPLE_ESCAPE[esc];
+                if (simple === undefined)
+                    return NOT_LITERAL; // `\x41`, `\0`, line continuation
+                out += simple;
+                this.pos += 2;
+                continue;
+            }
+            // JSON forbids raw control characters inside a string; so does this.
+            if (c < ' ')
+                return NOT_LITERAL;
+            out += c;
+            this.pos++;
+        }
+    }
+    array() {
+        this.pos++; // '['
+        const out = [];
+        this.ws();
+        if (this.src[this.pos] === ']') {
+            this.pos++;
+            return out;
+        }
+        for (;;) {
+            const item = this.value();
+            if (item === NOT_LITERAL)
+                return NOT_LITERAL;
+            out.push(item);
+            this.ws();
+            const c = this.src[this.pos];
+            // A trailing comma leaves `value()` facing `]`, which it refuses — so
+            // `['a',]` is NOT in the subset. Only two widenings were ruled.
+            if (c === ',') {
+                this.pos++;
+                continue;
+            }
+            if (c === ']') {
+                this.pos++;
+                return out;
+            }
+            return NOT_LITERAL;
+        }
+    }
+    object() {
+        this.pos++; // '{'
+        const out = {};
+        this.ws();
+        if (this.src[this.pos] === '}') {
+            this.pos++;
+            return out;
+        }
+        for (;;) {
+            this.ws();
+            const key = this.key();
+            if (key === NOT_LITERAL)
+                return NOT_LITERAL;
+            this.ws();
+            if (this.src[this.pos] !== ':')
+                return NOT_LITERAL;
+            this.pos++;
+            const item = this.value();
+            if (item === NOT_LITERAL)
+                return NOT_LITERAL;
+            // ⚠️ Plain `out[key] = item` would hand an authored `__proto__` key the
+            // prototype SETTER. `JSON.parse` creates an ordinary own data property,
+            // and this path must too: the whole point of this tier is that untrusted
+            // source is safe to parse, so a widening must not open a
+            // prototype-pollution lever the strict-JSON path never had.
+            Object.defineProperty(out, key, {
+                value: item,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+            this.ws();
+            const c = this.src[this.pos];
+            if (c === ',') {
+                this.pos++;
+                continue;
+            }
+            if (c === '}') {
+                this.pos++;
+                return out;
+            }
+            return NOT_LITERAL;
+        }
+    }
+    /** A quoted string, or a bare identifier — the second ruled widening. */
+    key() {
+        const c = this.src[this.pos];
+        if (c === '"' || c === "'")
+            return this.string(c);
+        if (c !== undefined && IDENT_START.test(c)) {
+            const start = this.pos;
+            this.pos++;
+            while (this.pos < this.src.length && IDENT_CHAR.test(this.src[this.pos]))
+                this.pos++;
+            return this.src.slice(start, this.pos);
+        }
+        return NOT_LITERAL;
     }
 }

package/dist/provenance.d.ts

@@ -6,10 +6,13 @@
  * 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 first-class,
- * permanently-supported tag in the html tier — the plain box element is exactly
- * that. 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
+ * 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.
  *

package/dist/provenance.js

@@ -6,10 +6,13 @@
  * 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 first-class,
- * permanently-supported tag in the html tier — the plain box element is exactly
- * that. 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
+ * 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.
  *

package/dist/types.d.ts

@@ -2,14 +2,24 @@
  * ObjectUI — SDUI JSX-source parser (ADR-0080)
  *
  * Types shared by the constrained JSX-source compiler. The parser turns a
- * constrained JSX *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;
 export interface SchemaElement {
     type: string;
-    children?: SchemaNode[];
+    children?: ParsedSchemaNode[];
     [prop: string]: unknown;
 }
 export type Severity = 'error' | 'warning';
@@ -53,22 +63,122 @@ export interface ManifestInput {
      * declared and every already-published entry serializes byte-identically.
      */
     type: ManifestInputType | ManifestInputType[];
+    /**
+     * The coarse kind of the input's MEMBERS — array elements, or the values of
+     * an object used as a map — as ONE kind or an ARRAY of kinds for a member
+     * contract that is a union (objectui#8067).
+     *
+     * Absent means "not declared", which is what every input published before
+     * this key existed says: {@link validateTree} checks no member and the
+     * codegen emits the unnarrowed element type, exactly as before. So a
+     * manifest gains this key only where a member kind was really declared, and
+     * every already-published entry serializes byte-identically.
+     *
+     * 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.
+     */
+    of?: ManifestInputType | ManifestInputType[];
     required?: boolean;
     /** allowed values for `enum` inputs */
     enum?: Array<string | {
         value: unknown;
         label?: string;
     }>;
-    /** marks a data-binding input the server must resolve (ADR-0080 §6.3) */
-    binding?: 'object' | 'field';
+    /**
+     * Marks a data-binding input the server must resolve (ADR-0080 §6.3):
+     * `binding: 'object'` says the input NAMES an object, so the server-side
+     * binding check knows what to resolve it against. Unrelated to
+     * `type: 'object'`, the coarse control kind — a record-shaped value and an
+     * object-naming input are two different facts.
+     *
+     * ## The vocabulary is exactly `'object'` — `'field'` is retired on this face too
+     *
+     * `'field'` stood beside it from the first draft of ADR-0080 and was never
+     * written. It was retired on the serializer's INPUT boundary
+     * (`RegistryConfigLike` in `index.ts`) under ADR-0049 enforce-or-remove by
+     * the maintainer ruling of 2026-09-07 (decision batch #69), and on THIS
+     * face by objectui#8315 — the residue that ruling did not name, which left
+     * one published package narrow on one face and wide on the other.
+     *
+     * ⚠️ The argument for leaving this face wide was ANSWERED, not overlooked.
+     * It runs: producer → reader is a subset relation, so a reader accepting a
+     * value no producer emits is permissive rather than wrong. Three measured
+     * facts decided against it (objectui#8315):
+     *
+     *   1. **This is not a pure reader face.** `manifestFromConfigs` RETURNS a
+     *      `Manifest`, so `ManifestInput` is also this package's OUTPUT type,
+     *      and this key is fed straight from the already-narrowed boundary. 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.**
+     *      `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
+     *      site, which is the lenient fallback AGENTS.md #0.1 bans. So "both
+     *      narrow" and "both wide" were the only self-consistent states, and
+     *      only one of them can be justified on the producer face.
+     *   3. **The permissiveness protected nothing.** `binding: 'field'` has
+     *      zero writers here and zero in the objectstack copy of this package
+     *      (measured 2026-09-09 on both heads, each with a firing
+     *      `binding: 'object'` control), and the only manifest producer in
+     *      either tree is `manifestFromConfigs`, whose input face is narrow.
+     *
+     * The reopen route is the ruling's own: a MEASURED need for field bindings
+     * is filed as a widening with the vocabulary decided then — not
+     * pre-declared here for a producer that does not exist.
+     */
+    binding?: 'object';
     description?: string;
 }
 export interface ManifestComponent {
     type: string;
     /** plugin namespace — provenance that drives `requires` */
     namespace?: string;
+    /**
+     * The declared authoring surface. An input named `children` (type `slot`)
+     * is ALSO the containment declaration: `validateTree` draws
+     * `not-a-container` on a child list under any component whose `inputs`
+     * 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.
+     * ⛔ Not "accepts children" — this tier's containment check does not read it.
+     */
     isContainer?: boolean;
+    /**
+     * The authoring tier this entry belongs to (objectui#10735).
+     *
+     * Absent = the curated PUBLIC tier (ADR-0080 §4), the JSON-surface
+     * AI-authoring vocabulary. `'html'` = one of the intrinsic HTML elements a
+     * `kind:'html'` page may author (ADR-0081 §2), declared by the registry's
+     * `HTML_TIER_INTRINSICS` roster and carried here so the ONE flat `components`
+     * map can serve both of its readers: a whitelist reader (`compile`, the
+     * objectstack gate) takes every key and needs no change; a reader that means
+     * the curated vocabulary — the `kind:'react'` scope, the block list, a census
+     * of curated blocks — filters this key out.
+     *
+     * ⛔ Not the registration's `tier` copied through. `manifestFromConfigs`
+     * writes exactly `'html'` or nothing, so every entry published before this
+     * key existed serialises byte-identically.
+     */
+    tier?: 'html';
 }
 export interface Manifest {
     /** keyed by component `type` */
@@ -94,11 +204,22 @@ export interface ManifestValidationResult {
     diagnostics: Diagnostic[];
     /** unique plugin namespaces referenced — the page's `requires` */
     requires: string[];
-    /** binding sites (object/field) the server must resolve against object schema */
+    /**
+     * Binding sites the server must resolve against object schema.
+     *
+     * `kind` is a PRODUCER face, not a reader face: `validateTree` writes it,
+     * copying {@link ManifestInput.binding} at the one site that builds this
+     * array. So the subset relation that licenses a permissive READER runs the
+     * other way here — a wider union accepts nothing extra, it obliges every
+     * consumer to handle an arm this package cannot emit. That is why the
+     * retired `'field'` arm (`9e37d9b39` on the input boundary, objectui#8315
+     * here) is gone from this end as well; the measurements are on
+     * {@link ManifestInput.binding}.
+     */
     bindings: Array<{
         tag: string;
         input: string;
-        kind: 'object' | 'field';
+        kind: 'object';
         value: unknown;
     }>;
 }

package/dist/types.js

@@ -2,7 +2,7 @@
  * ObjectUI — SDUI JSX-source parser (ADR-0080)
  *
  * Types shared by the constrained JSX-source compiler. The parser turns a
- * constrained JSX *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.
  */
 export {};