@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/directStructure.d.ts

@@ -1,7 +1,10 @@
 import type { DirectMessageRoot, DirectOperationContract } from './directOperation.js';
-import type { ElementNode, Reference } from './canonicalGraph.js';
+import type { AttributeNode, ElementNode, Reference } from './canonicalGraph.js';
 import type { ExpandedName, SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
+import type { DirectProjectionSlot } from './directStructurePlan.js';
+import type { SemanticContext } from './semanticContext.js';
 import type { ResolverUsage } from './semanticBudget.js';
+import type { ProjectionScalarList } from './projectionScalar.js';
 export type DirectDirection = Readonly<{
     kind: 'input' | 'output';
 } | {
@@ -9,7 +12,7 @@ export type DirectDirection = Readonly<{
     name: string;
 }>;
 export interface DirectScalarDuty {
-    readonly declaration: ElementNode;
+    readonly declaration: ElementNode | AttributeNode;
     readonly type: Reference;
     readonly builtin: ExpandedName;
     readonly lexical: string;
@@ -17,7 +20,74 @@ export interface DirectScalarDuty {
     readonly payloadSource: SyntaxSource;
     readonly payloadPath: string;
     readonly schemaPath: string;
+    readonly fixedCanonical?: string;
+    readonly retainLexical?: true;
+    readonly list?: ProjectionScalarList;
 }
+export type DirectMatchedNode = Readonly<{
+    kind: 'unassessed';
+    declaration: ElementNode;
+    payloadPath: string;
+    payload: SyntaxElement;
+} | {
+    kind: 'mixed-text';
+    declaration: ElementNode;
+    payloadPath: string;
+    value: string;
+} | {
+    kind: 'scalar';
+    declaration: ElementNode;
+    payloadPath: string;
+    operand: number;
+} | {
+    kind: 'record';
+    declaration: ElementNode;
+    payloadPath: string;
+    nil?: true;
+    keyed?: true;
+    namespaceChoices?: readonly string[];
+    dynamicDeclarations?: readonly ElementNode[];
+    namespaces?: Readonly<Record<string, string>>;
+    openAttributes?: readonly import('../loader/orderedSyntax.js').SyntaxAttribute[];
+    attributes: readonly Readonly<{
+        declaration: AttributeNode;
+        operand: number;
+        payloadPath: string;
+        bag?: true;
+        namespaceChoice?: true;
+        origin: 'present' | 'schema-default' | 'schema-fixed';
+    }>[];
+    text?: Extract<DirectMatchedNode, {
+        kind: 'scalar';
+    }>;
+    content?: readonly DirectMatchedNode[];
+    slots: readonly Readonly<{
+        slot: DirectProjectionSlot;
+        items: readonly DirectMatchedNode[];
+    }>[];
+}>;
+export type ProjectionStructuralResult = Readonly<{
+    kind: 'projection-match';
+    scope: 'structure-only';
+    scalarValidity: 'unassessed';
+    admitted: false;
+    root: ElementNode;
+    contextId: string;
+    tree: DirectMatchedNode;
+    occurrences: readonly DirectScalarDuty[];
+    usage: ResolverUsage;
+}> | Readonly<{
+    kind: 'mismatch' | 'unsupported' | 'cancelled' | 'resource-limit';
+    rule: string;
+    schemaPath?: string;
+    payloadPath?: string;
+    usage: ResolverUsage;
+}>;
+export type ProjectionStructuralMatch = Extract<ProjectionStructuralResult, {
+    kind: 'projection-match';
+}>;
+/** Native context identity authenticates structure only, never source validity or operation admission. */
+export declare function inspectProjectionStructuralMatch(match: unknown, context: SemanticContext): ProjectionStructuralMatch;
 export type DirectStructuralResult = Readonly<{
     kind: 'structural-match';
     scope: 'structure-only';
@@ -27,6 +97,7 @@ export type DirectStructuralResult = Readonly<{
     contextId: string;
     direction: DirectDirection;
     occurrences: readonly DirectScalarDuty[];
+    tree: DirectMatchedNode;
     usage: ResolverUsage;
 }> | Readonly<{
     kind: 'mismatch' | 'unsupported' | 'cancelled' | 'resource-limit';
@@ -41,11 +112,17 @@ export type DirectStructuralMatch = Extract<DirectStructuralResult, {
 /** Identity is checked before any receipt fields; no retrospective authentication. */
 export declare function inspectDirectStructuralMatch(match: unknown, expectedContract: DirectOperationContract): DirectStructuralMatch;
 /**
- * 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 declare function matchDirectProjection(context: SemanticContext, root: ElementNode, payload: SyntaxElement, options?: Readonly<{
+    signal?: AbortSignal;
+    flatOnly?: boolean;
+}>): ProjectionStructuralResult;
+/** Operation-owned flat preview wrapper; structured projection matches cannot bypass this gate. */
 export declare function matchDirectOperation(contract: DirectOperationContract, direction: DirectDirection, payload: SyntaxElement, options?: Readonly<{
     signal?: AbortSignal;
 }>): DirectStructuralResult;
-//# sourceMappingURL=directStructure.d.ts.map

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 } : {}) });
             };
-            if (rootBuiltin)
-                leaf(owned, root.element, rootBuiltin, '/0');
-            else {
+            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);
+            };
+            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,85 @@ 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 {
+                const selected = contract[ownedDirection.kind];
+                if ('parts' in selected)
+                    throw new Stop('unsupported', 'direct-document-root-required');
+                root = selected;
+            }
+            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;
         });