@object-ui/sdui-parser 17.6.0 → 17.7.0

package/dist/parse.js

@@ -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

@@ -53,22 +53,109 @@ 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[];
+    /**
+     * 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 +181,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/validate.d.ts

@@ -2,9 +2,116 @@
  * ObjectUI — SDUI tree validation against the registry manifest (ADR-0080 §3/§6)
  *
  * Shallow, author-time validation: unknown component, unknown/missing prop,
- * wrong coarse type, illegal enum value. Collects `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).
+ * wrong coarse type, illegal enum value, and containment — a child list under
+ * a component whose registration declares no `children` input draws
+ * `not-a-container` (objectui#9910; see `acceptsChildren`). Collects
+ * `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).
  */
-import type { Manifest, SchemaElement, ManifestValidationResult } from './types.js';
+import type { Manifest, ManifestComponent, SchemaElement, ManifestValidationResult } from './types.js';
+/**
+ * The protocol's ONE child-list key — `BaseSchema.children` — and therefore the
+ * name of the `inputs` entry a registration declares when its renderer puts
+ * that list on the page: `{ name: 'children', type: 'slot' }` (objectui#9910).
+ */
+export declare 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`. 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
+ * `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.
+ *
+ * ⛔ `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 declare function acceptsChildren(comp: Pick<ManifestComponent, 'inputs'>): boolean;
+/**
+ * Where a base prop is legal without a declaration (objectui#11044).
+ *
+ *  - `'every-node'` — on every node, and a registration's own input of the
+ *    same name is not consulted: {@link validateTree} skips the key before the
+ *    declared-input lookup.
+ *  - `'where-undeclared'` — on a type whose registration declares NO input of
+ *    that name. Where one does, the declared input wins, its `type-mismatch`
+ *    check included, and the generated JSX types take the declared type too.
+ */
+export type SduiBasePropScope = 'every-node' | 'where-undeclared';
+/** One entry of {@link SDUI_BASE_PROPS}. */
+export interface SduiBaseProp {
+    /** The `BaseSchema` member (`@object-ui/types`). */
+    readonly name: string;
+    readonly scope: SduiBasePropScope;
+    /**
+     * The attribute's type in the generated JSX surface (`SduiBaseProps` in
+     * `sdui-intrinsics.d.ts`), or `null` for the one key that is no attribute:
+     * `type`, which the tag name carries (`parse.ts` refuses a `type` attribute).
+     */
+    readonly tsType: string | null;
+}
+/**
+ * The base props: the `BaseSchema` members this tier accepts on a node without
+ * a registration declaring them. ONE list, read by BOTH of its consumers —
+ * {@link validateTree}'s `unknown-prop` branch and `generateDts`'s
+ * `SduiBaseProps` (objectui#11044). Before this list the two were separate
+ * hand-kept copies and had drifted: the validator accepted `bind` and `hidden`
+ * (objectui#11008) while the generated types still refused both.
+ *
+ * `bind` and `hidden` are `'every-node'` (objectui#11008). `BaseSchema` declares
+ * both for every node and no registration declares either as an input, so
+ * before they joined, the undeclared-key branch below answered every authored
+ * one with `unknown-prop` — "has no prop" about a key the protocol declares,
+ * on the nodes that honour it: `hidden` is read for every node by
+ * `SchemaRenderer`'s hide chain, and `bind` by every renderer that calls
+ * `useDataScope` (`list`, `tree-view`, the `object-*` widgets). The
+ * declaration outranks the implementation, so the parser's view is the
+ * declared type's, not a per-registration subset. The cost is accepted and
+ * named: a `bind` on a node that does not read it — `data-table`
+ * (objectui#6575) — draws nothing here either, and its render-time console
+ * warning is the one signal left.
+ *
+ * `visibleWhen`, `hiddenOn` and `testId` are `'every-node'` for the same reason
+ * (objectui#11044): no registration declares any of them, `SchemaRenderer`'s
+ * hide chain reads the first two for every node, and it strips `testId` and
+ * re-emits it as `data-testid`. `visibleWhen` is the canonical ADR-0089
+ * predicate; before it joined, the deprecated `visibleOn` was silent while it
+ * drew `unknown-prop`.
+ *
+ * The `'where-undeclared'` members (objectui#11044, triage ruling) are the
+ * `BaseSchema` members some registrations DECLARE as typed inputs — the input
+ * family's `placeholder`, `label`, `name`, … . Skipping them the way the
+ * `'every-node'` members are skipped would silence those registrations'
+ * `type-mismatch`, so they are base props only where the type declares no
+ * input of that name. ⛔ Never move one to `'every-node'` to accept a key: that
+ * silences a declared type check.
+ *
+ * Held over the live registry by `base-props-one-list-11044.test.tsx` in
+ * `@object-ui/components` — every member a `BaseSchema` member, and `body` the
+ * one member left out.
+ *
+ * ⛔ `body` is NOT here and must not be added. It was `BaseSchema`'s second
+ * child-list spelling until objectui#6771 retired it; teaching this list the
+ * key was the option that ruling refused, because it would have blessed a
+ * second permanent spelling of one concept. `./body-dialect.ts` answers it by
+ * name instead.
+ *
+ * `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
+ * {@link acceptsChildren} from the declared input.
+ */
+export declare const SDUI_BASE_PROPS: readonly SduiBaseProp[];
 export declare function validateTree(tree: SchemaElement | null, manifest: Manifest): ManifestValidationResult;