@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

package/dist/compiler/directStructure.js

@@ -1,6 +1,16 @@
 /** Internal direct case of the content-model matcher; never runtime admission. */
 import { inspectDirectOperation } from './directOperation.js';
-import { planDirectRoot } from './directStructurePlan.js';
+import { planDirectProjection, flatDirectProjection, matchOrderedProjection, selectProjectionAttribute, isXmlCharacters, isXmlNamespaceBinding } from './directStructurePlan.js';
+import { assertSemanticContext } from './semanticContext.js';
+import { isXmlNCName } from '../loader/orderedSyntax.js';
+const projectionIssued = new WeakMap();
+/** Native context identity authenticates structure only, never source validity or operation admission. */
+export function inspectProjectionStructuralMatch(match, context) {
+    assertSemanticContext(context);
+    if (!match || typeof match !== 'object' || projectionIssued.get(match) !== context)
+        throw new TypeError('Unauthenticated or foreign projection structural match');
+    return match;
+}
 const issued = new WeakMap();
 /** Identity is checked before any receipt fields; no retrospective authentication. */
 export function inspectDirectStructuralMatch(match, expectedContract) {
@@ -23,12 +33,14 @@ class Stop extends Error {
     }
 }
 /**
- * Data-only SyntaxElement input (plain records/arrays, no proxies/accessors). Malformed
- * input throws TypeError; XML structure differences return mismatch. No caller is frozen.
- * Cancellation is synchronous/cooperative, checked at visits and before publication.
+ * Match a data-only ordered XML tree against an actual native projection.
+ * @remarks The issued receipt establishes structure only, not source validity, scalar validity or operation admission.
+ * @constraints Plain records/arrays only; proxies and accessors are unsupported. No caller payload is frozen.
+ * @throws TypeError For malformed data-only trees or unauthenticated contexts.
+ * @returns A context-owned structural match or a mismatch, unsupported, cancellation or resource failure.
  */
-export function matchDirectOperation(contract, direction, payload, options = {}) {
-    const { context } = inspectDirectOperation(contract);
+export function matchDirectProjection(context, root, payload, options = {}) {
+    assertSemanticContext(context);
     const { budget } = context;
     const check = () => { budget.chargeWork(); if (options.signal?.aborted)
         throw new Stop('cancelled', 'cooperative-cancellation'); };
@@ -62,28 +74,27 @@ export function matchDirectOperation(contract, direction, payload, options = {})
             // Reserve fixed closures/state, diagnostics and terminal publication before input work.
             budget.chargeWork(4096);
             check();
-            const suppliedDirection = budget.snapshot(direction);
-            if (!record(suppliedDirection))
-                return malformed();
-            if (!['input', 'output', 'fault'].includes(suppliedDirection.kind))
-                return fail('unsupported', 'unknown-direction');
-            const ownedDirection = suppliedDirection.kind === 'fault'
-                ? { kind: 'fault', name: suppliedDirection.name } : { kind: suppliedDirection.kind };
-            let root;
-            if (ownedDirection.kind === 'fault') {
-                budget.chargeWork(64 + contract.faults.length * 32);
-                if (typeof ownedDirection.name !== 'string')
-                    return fail('unsupported', 'unknown-fault');
-                const selected = contract.faults.find(f => budget.compareText(f.name, ownedDirection.name) === 0);
-                if (!selected)
-                    return fail('unsupported', 'unknown-fault');
-                root = selected.root;
-            }
-            else
-                root = contract[ownedDirection.kind];
-            const schemaPath = root.element.context.source.path;
+            const schemaPath = root.context.source.path;
             const unsupported = () => fail('unsupported', 'native-direct-shape', schemaPath);
-            const { slots, rootBuiltin } = planDirectRoot(context, root, check, unsupported);
+            const plan = planDirectProjection(context, root, check, unsupported);
+            if (options.flatOnly)
+                flatDirectProjection(plan, check, unsupported);
+            const records = new Map(plan.records.map(record => [record.type.id, record]));
+            const wildcardPlans = new Map([[root, plan]]);
+            const wildcardValue = (element) => {
+                let selected = wildcardPlans.get(element);
+                if (!selected) {
+                    selected = planDirectProjection(context, element, check, unsupported);
+                    budget.chargeWork(64 + selected.records.length * 64);
+                    for (const record of selected.records) {
+                        check();
+                        if (!records.has(record.type.id))
+                            records.set(record.type.id, record);
+                    }
+                    wildcardPlans.set(element, selected);
+                }
+                return selected.root;
+            };
             // Count syntax nodes before copying. Descriptor reads reject accessors without invoking
             // them. A tree may not reuse a node, including cyclic input; proxies are out of contract.
             budget.chargeWork(128);
@@ -155,25 +166,12 @@ export function matchDirectOperation(contract, direction, payload, options = {})
                 if (node.attributes.length)
                     fail('unsupported', 'payload-attributes', declaration.context.source.path, path);
             };
-            attributes(owned, root.element, '/0');
-            if (!same(owned.name, root.element.name))
-                return mismatch('root-name', root.element, '/0');
+            if (!same(owned.name, root.name))
+                return mismatch('root-name', root, '/0');
             budget.chargeWork(64);
             const occurrences = [];
-            const leaf = (node, declaration, builtin, path) => {
-                attributes(node, declaration, path);
-                budget.chargeWork(64);
-                const parts = [];
-                let length = 0;
-                for (const child of node.children) {
-                    check();
-                    if (child.kind !== 'text')
-                        return mismatch('scalar-child', declaration, path);
-                    budget.chargeWork(32 + child.value.length * 4);
-                    parts.push(child.value);
-                    length += child.value.length;
-                }
-                budget.chargeWork(256 + length * 4 + path.length * 4);
+            const operand = (node, declaration, builtin, lexical, path, fixedCanonical, retainLexical, list) => {
+                budget.chargeWork(256 + lexical.length * 4 + path.length * 4);
                 // Project only typed retained facts. Generic snapshots deliberately preserve
                 // unknown values; caller extension fields must not become receipt authority.
                 const namespaces = Object.create(null);
@@ -188,22 +186,261 @@ export function matchDirectOperation(contract, direction, payload, options = {})
                 const payloadSource = budget.snapshot({ uri: s.uri, digest: s.digest, path: s.path,
                     start: { offset: s.start.offset, line: s.start.line, column: s.start.column },
                     end: { offset: s.end.offset, line: s.end.line, column: s.end.column } });
-                occurrences.push({ declaration, type: declaration.type, builtin, lexical: parts.join(''), namespaces,
-                    payloadSource, payloadPath: path, schemaPath: declaration.context.source.path });
+                occurrences.push({ declaration, type: declaration.type, builtin, lexical, namespaces,
+                    payloadSource, payloadPath: path, schemaPath: declaration.context.source.path,
+                    ...(fixedCanonical === undefined ? {} : { fixedCanonical }), ...(retainLexical ? { retainLexical } : {}), ...(list ? { list } : {}) });
+            };
+            const text = (node, declaration, path) => {
+                budget.chargeWork(64);
+                const parts = [];
+                for (const child of node.children) {
+                    check();
+                    if (child.kind !== 'text')
+                        return mismatch('scalar-child', declaration, path);
+                    budget.chargeWork(32 + child.value.length * 4);
+                    parts.push(child.value);
+                }
+                return parts.join('');
+            };
+            const elementOperand = (node, declaration, builtin, path, shape, retainLexical, list) => {
+                const lexical = text(node, declaration, path);
+                operand(node, declaration, builtin, lexical === '' && shape.constraint ? shape.constraint.lexical : lexical, path, shape.constraint?.kind === 'fixed' ? shape.constraint.canonical : undefined, retainLexical, list);
             };
-            if (rootBuiltin)
-                leaf(owned, root.element, rootBuiltin, '/0');
-            else {
+            const leaf = (node, declaration, builtin, path, shape, retainLexical, list) => {
+                attributes(node, declaration, path);
+                elementOperand(node, declaration, builtin, path, shape, retainLexical, list);
+            };
+            const roots = [];
+            const frames = [{ node: owned, declaration: root, value: plan.root, path: '/0', into: roots }];
+            while (frames.length) {
+                check();
+                const frame = frames.pop();
+                const { declaration, path: parentPath } = frame;
+                let node = frame.node;
+                budget.chargeWork(128 + parentPath.length * 4);
+                if (node.kind === 'text') {
+                    if (!isXmlCharacters(node.value))
+                        return mismatch('xml-characters', declaration, parentPath);
+                    frame.into.push({ kind: 'mixed-text', declaration, payloadPath: parentPath, value: node.value });
+                    continue;
+                }
+                if (frame.unassessed) {
+                    const pending = [node];
+                    while (pending.length) {
+                        check();
+                        const value = pending.pop();
+                        budget.chargeWork(64);
+                        if (value.kind === 'text') {
+                            if (!isXmlCharacters(value.value))
+                                return mismatch('xml-characters', declaration, value.source.path);
+                            continue;
+                        }
+                        if (!isXmlNCName(value.name.local) || !isXmlCharacters(value.name.namespace) || value.name.namespace === 'http://www.w3.org/2000/xmlns/')
+                            return mismatch('expanded-name-required', declaration, value.source.path);
+                        for (const prefix in value.namespaces) {
+                            check();
+                            if (!isXmlNamespaceBinding(prefix, value.namespaces[prefix]))
+                                return mismatch('namespace-binding', declaration, value.source.path);
+                        }
+                        const identities = new Set();
+                        for (const attribute of value.attributes) {
+                            check();
+                            const key = JSON.stringify([attribute.name.namespace, attribute.name.local]);
+                            budget.chargeWork(64 + key.length * 4 + attribute.value.length);
+                            if (!isXmlNCName(attribute.name.local) || attribute.name.local === 'xmlns' && attribute.name.namespace === '' || attribute.name.namespace === 'http://www.w3.org/2000/xmlns/' || !isXmlCharacters(attribute.name.namespace))
+                                return mismatch('attribute-name', declaration, value.source.path);
+                            if (!isXmlCharacters(attribute.value))
+                                return mismatch('xml-characters', declaration, value.source.path);
+                            if (identities.has(key))
+                                return mismatch('duplicate-attribute', declaration, value.source.path);
+                            identities.add(key);
+                        }
+                        for (const child of value.children) {
+                            check();
+                            pending.push(child);
+                        }
+                    }
+                    frame.into.push({ kind: 'unassessed', declaration, payloadPath: parentPath, payload: node });
+                    continue;
+                }
+                let nil = false;
+                const nilAttributes = node.attributes.filter(attribute => {
+                    check();
+                    return attribute.name.namespace === 'http://www.w3.org/2001/XMLSchema-instance' && attribute.name.local === 'nil';
+                });
+                if (nilAttributes.length) {
+                    if (options.flatOnly)
+                        return fail('unsupported', 'payload-attributes', declaration.context.source.path, parentPath);
+                    if (nilAttributes.length !== 1)
+                        return mismatch('duplicate-nil', declaration, parentPath);
+                    const lexical = nilAttributes[0].value.replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, '');
+                    if (!['true', '1', 'false', '0'].includes(lexical))
+                        return mismatch('nil-lexical', declaration, parentPath);
+                    nil = lexical === 'true' || lexical === '1';
+                    if (nil && !frame.value.nillable)
+                        return mismatch('non-nillable', declaration, parentPath);
+                    if (nil && frame.value.constraint?.kind === 'fixed')
+                        return mismatch('nil-fixed-value', declaration, parentPath);
+                    if (nil && node.children.length)
+                        return mismatch('nil-content', declaration, parentPath);
+                    node = { ...node, attributes: node.attributes.filter(attribute => { check(); return !nilAttributes.includes(attribute); }) };
+                }
+                if (frame.value.kind === 'scalar') {
+                    if (nil) {
+                        attributes(node, declaration, parentPath);
+                        frame.into.push({ kind: 'record', nil: true, declaration, payloadPath: parentPath, attributes: [], slots: [] });
+                        continue;
+                    }
+                    const operand = occurrences.length;
+                    leaf(node, declaration, frame.value.builtin, parentPath, frame.value, frame.value.retainLexical, frame.value.list);
+                    frame.into.push({ kind: 'scalar', declaration, payloadPath: parentPath, operand });
+                    continue;
+                }
+                const record = records.get(frame.value.type);
+                if (!record)
+                    return unsupported();
+                if (record.contextual)
+                    for (const prefix in node.namespaces) {
+                        check();
+                        if (!isXmlNamespaceBinding(prefix, node.namespaces[prefix]))
+                            return mismatch('namespace-binding', declaration, parentPath);
+                    }
+                // @why XSD 1.0 cvc-complex-type.2.1 forbids even whitespace character children for empty content.
+                if (record.content === 'empty' && node.children.length)
+                    return mismatch('empty-content', declaration, parentPath);
+                const matchedAttributes = [];
+                const openAttributes = [];
+                const attributeChannel = (expected) => ({ ...(expected.bag ? { bag: true } : {}),
+                    ...(expected.bag && expected.declaration.name.namespace && (record.attributeWildcard
+                        || record.attributes.some(other => other !== expected && other.declaration.name.local === expected.declaration.name.local)) ? { namespaceChoice: true } : {}) });
+                if (!record.attributes.length && !record.attributeWildcard)
+                    attributes(node, declaration, parentPath);
+                else {
+                    const present = new Set();
+                    for (let index = 0; index < node.attributes.length; index++) {
+                        check();
+                        const attribute = node.attributes[index];
+                        const path = `${parentPath}/attributes/${index}`;
+                        let expected = record.attributes.find(item => { check(); return same(item.declaration.name, attribute.name); });
+                        let dynamic = false;
+                        if (!expected) {
+                            const selected = selectProjectionAttribute(context, record, attribute.name, check, unsupported);
+                            if (!selected)
+                                return mismatch('unknown-attribute', declaration, path);
+                            if (!selected.attribute) {
+                                if (!isXmlNCName(attribute.name.local) || attribute.name.local === 'xmlns' && attribute.name.namespace === ''
+                                    || attribute.name.namespace === 'http://www.w3.org/2000/xmlns/' || !isXmlCharacters(attribute.name.namespace))
+                                    return mismatch('attribute-name', declaration, path);
+                                if (!isXmlCharacters(attribute.value))
+                                    return mismatch('xml-characters', declaration, path);
+                                const key = JSON.stringify([attribute.name.namespace, attribute.name.local]);
+                                if (present.has(key))
+                                    return mismatch('duplicate-attribute', declaration, path);
+                                present.add(key);
+                                openAttributes.push(attribute);
+                                continue;
+                            }
+                            expected = selected.attribute;
+                            dynamic = true;
+                        }
+                        if (present.has(expected.declaration.id))
+                            return mismatch('duplicate-attribute', declaration, path);
+                        budget.chargeWork(128 + expected.declaration.id.length);
+                        present.add(expected.declaration.id);
+                        matchedAttributes.push({ declaration: expected.declaration, operand: occurrences.length, payloadPath: path, origin: 'present',
+                            ...(dynamic ? { bag: true, ...(attribute.name.namespace ? { namespaceChoice: true } : {}) } : attributeChannel(expected)) });
+                        operand(node, expected.declaration, expected.builtin, attribute.value, path, expected.constraint?.kind === 'fixed' ? expected.constraint.canonical : undefined, expected.retainLexical, expected.list);
+                    }
+                    for (const expected of record.attributes) {
+                        check();
+                        if (expected.required && !present.has(expected.declaration.id))
+                            return mismatch('missing-required-attribute', declaration, parentPath);
+                        if (!present.has(expected.declaration.id) && expected.constraint) {
+                            budget.chargeWork(128 + expected.declaration.id.length * 4);
+                            const path = `${parentPath}/@schema-${expected.constraint.kind}/${encodeURIComponent(expected.declaration.id)}`;
+                            matchedAttributes.push({ declaration: expected.declaration, operand: occurrences.length, payloadPath: path,
+                                ...attributeChannel(expected),
+                                origin: expected.constraint.kind === 'fixed' ? 'schema-fixed' : 'schema-default' });
+                            operand(node, expected.declaration, expected.builtin, expected.constraint.lexical, path, expected.constraint.kind === 'fixed' ? expected.constraint.canonical : undefined, expected.retainLexical, expected.list);
+                        }
+                    }
+                }
+                if (nil) {
+                    frame.into.push({ kind: 'record', nil: true, declaration, payloadPath: parentPath, slots: [], attributes: matchedAttributes,
+                        openAttributes,
+                        ...(record.contextual ? { namespaces: node.namespaces } : {}) });
+                    continue;
+                }
+                if (record.content === 'simple') {
+                    if (!record.text)
+                        throw new TypeError('Missing native simple content plan');
+                    const path = `${parentPath}/text`, index = occurrences.length;
+                    elementOperand(node, declaration, record.text.builtin, path, frame.value, record.text.retainLexical, record.text.list);
+                    frame.into.push({ kind: 'record', declaration, payloadPath: parentPath, slots: [], attributes: matchedAttributes,
+                        openAttributes, ...(record.contextual ? { namespaces: node.namespaces } : {}),
+                        text: { kind: 'scalar', declaration, payloadPath: path, operand: index } });
+                    continue;
+                }
+                const slots = record.slots;
+                if (record.ordered) {
+                    const elements = [];
+                    for (let index = 0; index < node.children.length; index++) {
+                        check();
+                        const child = node.children[index], path = `${parentPath}/children/${index}`;
+                        budget.chargeWork(64);
+                        if (child.kind === 'text') {
+                            budget.chargeWork(child.value.length * 2);
+                            if (record.content !== 'mixed' && /[^\t\r\n ]/.test(child.value))
+                                return mismatch('complex-text', declaration, path);
+                        }
+                        else
+                            elements.push({ node: child, path });
+                    }
+                    const selected = matchOrderedProjection(context, record, elements.map(item => { check(); return item.node.name; }), check);
+                    if (!selected)
+                        return mismatch('ordered-particle-language', declaration, parentPath);
+                    const content = [];
+                    frame.into.push({ kind: 'record', declaration, payloadPath: parentPath, slots: [], attributes: matchedAttributes, content,
+                        openAttributes,
+                        ...(record.contextual ? { namespaces: node.namespaces } : {}),
+                        namespaceChoices: slots.filter(slot => !record.fixedOrder && slots.some(other => other !== slot && other.element.name.local === slot.element.name.local)).map(slot => slot.element.name.local),
+                        dynamicDeclarations: selected.filter(slot => !('value' in slot) && slot.element).map(slot => slot.element),
+                        ...(record.keyed ? { keyed: true } : {}) });
+                    let selectedIndex = elements.length - 1;
+                    for (let index = node.children.length - 1; index >= 0; index--) {
+                        check();
+                        const child = node.children[index];
+                        if (child.kind === 'text') {
+                            if (record.content === 'mixed')
+                                frames.push({ node: child, path: `${parentPath}/children/${index}`, declaration, value: frame.value, into: content });
+                            continue;
+                        }
+                        const item = elements[selectedIndex], slot = selected[selectedIndex--];
+                        if (!slot.element) {
+                            frames.push({ node: item.node, path: item.path, declaration, value: frame.value, unassessed: true, into: content });
+                            continue;
+                        }
+                        frames.push({ node: item.node, path: item.path, declaration: slot.element,
+                            value: 'value' in slot ? slot.value : wildcardValue(slot.element), into: content });
+                    }
+                    continue;
+                }
+                budget.chargeWork(64 + slots.length * 128);
+                const matchedSlots = slots.map(slot => { check(); return { slot, items: [] }; });
+                frame.into.push({ kind: 'record', declaration, payloadPath: parentPath, slots: matchedSlots, attributes: matchedAttributes,
+                    openAttributes,
+                    ...(record.contextual ? { namespaces: node.namespaces } : {}) });
+                const children = [];
                 let cursor = 0, count = 0;
-                for (let index = 0; index < owned.children.length; index++) {
+                for (let index = 0; index < node.children.length; index++) {
                     check();
-                    const child = owned.children[index];
+                    const child = node.children[index];
                     budget.chargeWork(64);
-                    const path = `/0/children/${index}`;
+                    const path = `${parentPath}/children/${index}`;
                     if (child.kind === 'text') {
                         budget.chargeWork(child.value.length * 2);
                         if (/[^\t\r\n ]/.test(child.value))
-                            return mismatch('complex-text', root.element, path);
+                            return mismatch('complex-text', declaration, path);
                         continue;
                     }
                     while (cursor < slots.length && !same(child.name, slots[cursor].element.name)) {
@@ -216,27 +453,81 @@ export function matchDirectOperation(contract, direction, payload, options = {})
                     }
                     const slot = slots[cursor];
                     if (!slot)
-                        return mismatch('unexpected-child', root.element, path);
+                        return mismatch('unexpected-child', declaration, path);
                     if (slot.particle.occurs.max === '1' && count === 1)
                         return mismatch('duplicate-singleton', slot.element, path);
-                    leaf(child, slot.element, slot.builtin, path);
+                    children.push({ node: child, declaration: slot.element, value: slot.value, path, into: matchedSlots[cursor].items });
                     count++;
                 }
                 for (; cursor < slots.length; cursor++, count = 0) {
                     check();
                     const slot = slots[cursor];
                     if (slot.particle.occurs.min === '1' && count === 0)
-                        return mismatch('missing-required', slot.element, '/0/end');
+                        return mismatch('missing-required', slot.element, `${parentPath}/end`);
+                }
+                // @why Preserve document order and record boundaries without recursive JS calls.
+                for (let i = children.length - 1; i >= 0; i--) {
+                    check();
+                    frames.push(children[i]);
                 }
             }
             check();
             budget.chargeWork(512);
-            const result = { kind: 'structural-match', scope: 'structure-only', scalarValidity: 'unassessed', admitted: false,
-                root, contextId: context.contextId, direction: ownedDirection, occurrences, usage: { ...budget.usage() } };
+            const result = { kind: 'projection-match', scope: 'structure-only', scalarValidity: 'unassessed', admitted: false,
+                root, contextId: context.contextId, tree: roots[0], occurrences, usage: { ...budget.usage() } };
             budget.freeze(result);
             check();
             // Capture final accounting after publication traversal; the record is already reserved.
             const published = Object.freeze({ ...result, usage: Object.freeze({ ...budget.usage() }) });
+            projectionIssued.set(published, context);
+            return published;
+        });
+        return guarded.kind === 'resource-limit' ? Object.freeze({ kind: 'resource-limit', rule: 'request-budget', usage: budget.usage() }) : guarded;
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return Object.freeze({ kind: 'resource-limit', rule: 'request-budget', usage: budget.usage() });
+        if (error instanceof Stop)
+            return Object.freeze({ kind: error.kind, rule: error.rule, schemaPath: error.schemaPath, payloadPath: error.payloadPath, usage: Object.freeze({ ...budget.usage() }) });
+        throw error;
+    }
+}
+/** Operation-owned flat preview wrapper; structured projection matches cannot bypass this gate. */
+export function matchDirectOperation(contract, direction, payload, options = {}) {
+    const { context } = inspectDirectOperation(contract);
+    const { budget } = context;
+    try {
+        const guarded = budget.guard(() => {
+            const supplied = budget.snapshot(direction);
+            if (!supplied || typeof supplied !== 'object' || Array.isArray(supplied))
+                throw new TypeError('Direct direction requires a data-only record');
+            if (!['input', 'output', 'fault'].includes(supplied.kind))
+                throw new Stop('unsupported', 'unknown-direction');
+            const ownedDirection = supplied.kind === 'fault' ? { kind: 'fault', name: supplied.name } : { kind: supplied.kind };
+            let root;
+            if (ownedDirection.kind === 'fault') {
+                budget.chargeWork(64 + contract.faults.length * 32);
+                if (typeof ownedDirection.name !== 'string')
+                    throw new Stop('unsupported', 'unknown-fault');
+                const selected = contract.faults.find(fault => budget.compareText(fault.name, ownedDirection.name) === 0);
+                if (!selected)
+                    throw new Stop('unsupported', 'unknown-fault');
+                root = selected.root;
+            }
+            else
+                root = contract[ownedDirection.kind];
+            const matched = matchDirectProjection(context, root.element, payload, { ...options, flatOnly: true });
+            if (matched.kind !== 'projection-match')
+                return matched;
+            inspectProjectionStructuralMatch(matched, context);
+            budget.chargeWork(512);
+            const result = { kind: 'structural-match', scope: matched.scope, scalarValidity: matched.scalarValidity, admitted: false,
+                root, contextId: context.contextId, direction: ownedDirection, occurrences: matched.occurrences, tree: matched.tree, usage: { ...budget.usage() } };
+            budget.freeze(result);
+            budget.chargeWork();
+            if (options.signal?.aborted)
+                throw new Stop('cancelled', 'cooperative-cancellation');
+            const published = Object.freeze({ ...result, usage: Object.freeze({ ...budget.usage() }) });
             issued.set(published, contract);
             return published;
         });

package/dist/compiler/directStructurePlan.d.ts

@@ -1,8 +1,11 @@
 /** Single native direct slot interpretation shared by matching and value mapping. */
 import type { DirectMessageRoot } from './directOperation.js';
 import type { SemanticContext } from './semanticContext.js';
-import type { ElementNode, ParticleNode } from './canonicalGraph.js';
+import type { AttributeNode, ComplexTypeNode, ElementNode, NodeId, ParticleNode } from './canonicalGraph.js';
 import type { ExpandedName } from '../loader/orderedSyntax.js';
+import type { ProjectionScalarList } from './projectionScalar.js';
+import type { SemanticParticle, SemanticParticleView } from './particleSemanticView.js';
+import type { AttributeWildcard } from './schemaAttributeUses.js';
 export interface DirectSlot {
     readonly element: ElementNode;
     readonly particle: ParticleNode;
@@ -12,5 +15,135 @@ export interface DirectRootPlan {
     readonly rootBuiltin?: ExpandedName;
     readonly slots: readonly DirectSlot[];
 }
+export type DirectProjectionValue = Readonly<({
+    kind: 'scalar';
+    builtin: ExpandedName;
+    declared?: true;
+    retainLexical?: true;
+    list?: ProjectionScalarList;
+} | {
+    kind: 'record';
+    type: NodeId;
+}) & {
+    nillable?: true;
+    constraint?: Readonly<{
+        kind: 'fixed' | 'default';
+        lexical: string;
+        canonical: string;
+    }>;
+}>;
+export interface DirectProjectionSlot {
+    readonly element: ElementNode;
+    readonly particle: ParticleNode;
+    readonly value: DirectProjectionValue;
+}
+export interface DirectProjectionAttribute {
+    readonly bag?: true;
+    readonly declaration: AttributeNode;
+    readonly required: boolean;
+    readonly builtin: ExpandedName;
+    readonly constraint?: Readonly<{
+        kind: 'fixed' | 'default';
+        lexical: string;
+        canonical: string;
+    }>;
+    readonly retainLexical?: true;
+    readonly list?: ProjectionScalarList;
+}
+export interface DirectProjectionRecord {
+    readonly type: ComplexTypeNode;
+    readonly slots: readonly DirectProjectionSlot[];
+    readonly attributes: readonly DirectProjectionAttribute[];
+    readonly content: 'empty' | 'element-only' | 'simple' | 'mixed';
+    readonly text?: Extract<DirectProjectionValue, {
+        kind: 'scalar';
+    }>;
+    readonly keyed?: true;
+    readonly fixedOrder?: true;
+    readonly contextual?: true;
+    readonly attributeWildcard?: AttributeWildcard;
+    readonly ordered?: true;
+}
+export type DirectProjectionSelection = DirectProjectionSlot | Readonly<{
+    kind: 'wildcard';
+    element?: ElementNode;
+    particle: ParticleNode;
+}>;
+/** Inspect source particles only after authenticating their projection owner. */
+export declare function inspectProjectionGrammar(context: SemanticContext, record: DirectProjectionRecord): Readonly<{
+    view: SemanticParticleView;
+    first(particle: SemanticParticle): readonly string[];
+    bodyNullable(particle: SemanticParticle): boolean;
+    slot(key: string): DirectProjectionSlot | undefined;
+}> | undefined;
+/** Match ordered children using authenticated native particles, without granting source or operation admission.
+ * @constraints Leaf alphabets must be disjoint; native strict/lax/skip policy selects declaration assessment or unassessed preservation.
+ * @returns Source-owned slots in document order, or undefined when the child sequence is outside the particle language.
+ * @throws TypeError For an unauthenticated record or foreign context.
+ */
+export declare function matchOrderedProjection(context: SemanticContext, record: DirectProjectionRecord, names: readonly ExpandedName[], check: () => void): readonly DirectProjectionSelection[] | undefined;
+/** Resolve a policy-assessed wildcard declaration, never from a caller-supplied type or companion-name guess.
+ * @returns The source declaration, or undefined for an excluded namespace, missing declaration or incomplete universe.
+ * @throws TypeError For copied/foreign projection records.
+ */
+export declare function resolveProjectionWildcard(context: SemanticContext, record: DirectProjectionRecord, name: ExpandedName, check: () => void): ElementNode | undefined;
+/** Select native application wildcard policy from the authenticated particle, without payload-driven schema acquisition.
+ * @param context Exact source context owning the record.
+ * @param record Authenticated projection record.
+ * @param name Actual expanded payload identity.
+ * @param check Budget and cancellation checkpoint.
+ * @returns Declaration assessment, an unassessed native policy selection, or no match.
+ * @throws TypeError For a foreign or copied record.
+ */
+export declare function selectProjectionWildcard(context: SemanticContext, record: DirectProjectionRecord, name: ExpandedName, check: () => void): Readonly<{
+    element?: ElementNode;
+}> | undefined;
+export interface DirectProjectionPlan {
+    readonly root: DirectProjectionValue;
+    readonly records: readonly DirectProjectionRecord[];
+}
+/** Inspect wildcard presence on an exact ordered plan; this describes existing grammar, never adds admission. */
+export declare function inspectOrderedProjectionWildcards(context: SemanticContext, record: DirectProjectionRecord): boolean;
+/** Inspect whether every wildcard on an authenticated ordered record requires unassessed preservation. */
+export declare function inspectUnassessedProjectionWildcards(context: SemanticContext, record: DirectProjectionRecord): boolean;
+/** Capability diagnostic only; this record neither proves schema invalidity nor grants admission. */
+export interface DirectProjectionUnavailable {
+    readonly rule: string;
+    readonly component: NodeId;
+    readonly schemaPath: string;
+}
+/** JSON representation policy only; native datatype calculations decide lexical/value validity. */
+export declare function projectionScalarRepresentation(name: ExpandedName): 'string' | 'number' | 'boolean' | undefined;
+/** Test projected XML 1.0 character data without interpreting lexical application strings. */
+export declare const isXmlCharacters: (value: string) => boolean;
+/** Check a projected Namespaces 1.0 binding; the empty key denotes the default namespace. */
+export declare const isXmlNamespaceBinding: (prefix: string, namespace: string) => boolean;
+/** Resolve and plan an application attribute permitted by the source wildcard.
+ * @param context Exact source context.
+ * @param record Source-derived record containing the native attribute policy.
+ * @param name Expanded payload attribute identity.
+ * @param check Budget and cancellation checkpoint.
+ * @param unsupported Existing diagnostic owner for unavailable native scalar duties.
+ * @returns A typed declaration, unassessed lexical selection, or no policy match.
+ * @throws TypeError For a non-actual context.
+ */
+export declare function selectProjectionAttribute(context: SemanticContext, record: DirectProjectionRecord, name: ExpandedName, check: () => void, unsupported: () => never): Readonly<{
+    attribute?: DirectProjectionAttribute;
+}> | undefined;
+/**
+ * Derive record structure using native component identity, including anonymous scopes and recursion.
+ * @remarks This is a projection plan, not source validity, correspondence or runtime admission.
+ *   Effective sequences and known attributes of explicitly represented builtin scalars are supported.
+ *   Exact numeric families and temporal/binary values use strings; QName and document-wide ID/ENTITY duties are outside this plan.
+ *   Inheritance is read from native content and attribute owners; only unit sequence groups flatten into peer properties.
+ *   Other represented particles retain ordered children in $content; disjoint element/wildcard alphabets are required.
+ *   Source-selected keyed content and attribute fallback preserve mixed text and local-name collisions.
+ *   Native wildcard policies select known declaration duties or lexical preservation; retained scopes propagate through known intermediates.
+ *   Native default/fixed values are explicit XML-assessment augmentation, never a missing required application field.
+ *   The checked-direct preview adapter below retains its flat-only grammar.
+ */
+export declare function planDirectProjection(context: SemanticContext, root: ElementNode, check: () => void, unsupported: (detail?: DirectProjectionUnavailable) => never): DirectProjectionPlan;
+/** Adapt the native projection to the supported flat preview without widening admission. */
 export declare function planDirectRoot(context: SemanticContext, root: DirectMessageRoot, check: () => void, unsupported: () => never): DirectRootPlan;
-//# sourceMappingURL=directStructurePlan.d.ts.map
+/** Flat-only projection adapter; its input is derived data, never native admission. */
+export declare function flatDirectProjection(plan: DirectProjectionPlan, check: () => void, unsupported: () => never): DirectRootPlan;