@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/componentCorrespondence.js

@@ -0,0 +1,140 @@
+import { resolveLexicalQName, syntaxAttribute, syntaxElements, XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { isBuiltinType } from './canonicalGraph.js';
+import { inspectNativeSourceConstruction } from './checkedSourcePreparation.js';
+import { assertSimpleExtensionConstruction } from './finiteRe01Verification.js';
+import { scalarSchemaAssessment } from './scalarSchemaAssessment.js';
+import { schemaScalarContext } from './schemaScalarContext.js';
+export const COMPONENT_CORRESPONDENCE = 'dated-XSD-2004-components-v1';
+const issued = new WeakMap();
+/** Receipt identity binds correspondence to the exact fresh native construction, never a diagnostic digest. */
+export function inspectComponentCorrespondence(value, construction) {
+    if (issued.get(value) !== construction)
+        throw new TypeError('Fresh matching component correspondence required');
+    inspectNativeSourceConstruction(construction);
+    return value;
+}
+const forms = new Set(['schema', 'import', 'include', 'annotation', 'complexType', 'simpleType', 'complexContent', 'simpleContent',
+    'extension', 'restriction', 'enumeration', 'list', 'union', 'length', 'minLength', 'maxLength', 'whiteSpace', 'pattern',
+    'minInclusive', 'maxInclusive', 'minExclusive', 'maxExclusive', 'totalDigits', 'fractionDigits',
+    'element', 'attribute', 'attributeGroup', 'sequence', 'choice', 'all', 'group', 'any', 'anyAttribute']);
+const contextual = new Set(['QName', 'NOTATION', 'ID', 'IDREF', 'IDREFS', 'ENTITY', 'ENTITIES', 'anyType', 'anySimpleType']);
+/** Audit a closed representation fragment after whole native construction; this is not a second schema checker.
+ * @remarks Source syntax/values and component legality remain the native S4S, construction and aggregate owners.
+ *   This sufficient route excludes redefine/chameleon, identity/substitution, non-string unions and wider faceted families,
+ *   source complex restrictions, contextual/explicit ur-type references, foreign attributes and endpoint-shadowing witnesses.
+ *   Endpoint-shadowing witnesses remain inconclusive until component-valued TYPE/SCOPE interpretation is established.
+ * @returns An authenticated correspondence or an inconclusive scope/resource result; never a schema-invalid judgment.
+ * @throws TypeError For copied/foreign construction or source. Cancellation callbacks propagate unchanged.
+ */
+export function checkComponentCorrespondence(input, supplied, options = {}) {
+    const construction = inspectNativeSourceConstruction(supplied, input);
+    const actual = construction.request.actual, { budget } = actual;
+    const check = () => { options.check?.(); budget.chargeWork(); };
+    const outside = (rule, node) => {
+        budget.chargeWork(64 + rule.length * 4);
+        return Object.freeze({ kind: 'inconclusive-correspondence', rule, ...(node ? { path: node.source.path } : {}), usage: Object.freeze({ ...budget.usage() }) });
+    };
+    return budget.guard(() => {
+        check();
+        if (!construction.nativeEstablished)
+            return outside('native-construction-unestablished');
+        if (!input.schemas.length)
+            return outside('no-schema-interpretation');
+        for (const schema of input.schemas) {
+            check();
+            budget.chargeWork(128 + schema.targetNamespace.length * 4);
+            if (schema.targetNamespace === XSD_NAMESPACE || schema.targetNamespace === 'http://www.w3.org/2000/xmlns/')
+                return outside('system-namespace-unqualified', schema.syntax);
+            if (schema.context.kind === 'include' && syntaxAttribute(schema.syntax, 'targetNamespace') === undefined && schema.targetNamespace !== '')
+                return outside('chameleon-interpretation', schema.syntax);
+            const stack = [{ node: schema.syntax }];
+            while (stack.length) {
+                check();
+                const { node, parent } = stack.pop();
+                budget.chargeWork(96 + node.attributes.length * 32 + node.children.length * 8);
+                if (node.name.namespace !== XSD_NAMESPACE || !forms.has(node.name.local))
+                    return outside('source-form-' + node.name.local, node);
+                // @why Annotation contents are data under 2004 S4S; the native document owner already checks their syntax and IDs.
+                if (node.name.local === 'annotation')
+                    continue;
+                if (node.name.local === 'restriction' && parent?.name.local !== 'simpleType')
+                    return outside('source-complex-restriction', node);
+                for (const attribute of node.attributes) {
+                    check();
+                    budget.chargeWork(64 + attribute.value.length * 4);
+                    if (attribute.name.namespace !== '')
+                        return outside('foreign-source-attribute', node);
+                    if (attribute.name.local === 'substitutionGroup')
+                        return outside('source-substitution', node);
+                    if (['type', 'base', 'itemType', 'memberTypes'].includes(attribute.name.local)) {
+                        const words = attribute.name.local === 'memberTypes' ? attribute.value.trim().split(/[\t\r\n ]+/) : [attribute.value];
+                        for (const word of words) {
+                            check();
+                            const name = resolveLexicalQName(word, node);
+                            if (name.namespace === XSD_NAMESPACE && (!isBuiltinType(name.local) || contextual.has(name.local)))
+                                return outside('scalar-correspondence-scope', node);
+                        }
+                    }
+                }
+                if (['element', 'attribute'].includes(node.name.local) && syntaxAttribute(node, 'type') === undefined && syntaxAttribute(node, 'ref') === undefined
+                    && !syntaxElements(node).some(child => child.name.namespace === XSD_NAMESPACE && ['simpleType', 'complexType'].includes(child.name.local)))
+                    return outside('implicit-opaque-declaration-type', node);
+                for (const child of syntaxElements(node)) {
+                    check();
+                    stack.push({ node: child, parent: node });
+                }
+            }
+        }
+        // @why #422 audits all actual named/inline/inherited scalar components after whole native formation.
+        //   Native plans own flattened member order, QName resolution, facets and obligations; syntax alone grants no receipt.
+        const scalar = scalarSchemaAssessment(schemaScalarContext(actual));
+        for (const id of actual.members) {
+            check();
+            const found = actual.lookup(id);
+            if (found.kind !== 'found' || found.node.kind !== 'simpleType')
+                continue;
+            const owner = found.node, plan = scalar.ensure({ kind: 'local', target: id }, owner);
+            if (plan.obligations?.length)
+                return outside('scalar-source-obligations');
+            if (plan.variety === 'union') {
+                for (const reference of plan.members ?? []) {
+                    check();
+                    const member = scalar.ensure(reference, owner);
+                    if (member.variety !== 'atomic' || member.primitive !== 'string' || member.obligations?.length)
+                        return outside('scalar-union-correspondence-scope');
+                }
+            }
+            if (plan.variety === 'atomic' && plan.layers.some(layer => layer.facets.some(facet => !['enumeration', 'whiteSpace'].includes(facet.name)))
+                && plan.primitive !== 'string' && plan.primitive !== 'decimal')
+                return outside('scalar-facet-correspondence-scope');
+        }
+        const closure = construction.closure;
+        const proof = 'proof' in closure ? closure.proof : [];
+        if (proof.length)
+            return outside('constructed-component-interpretation-unestablished');
+        if ('actualScalarSlots' in closure && closure.actualScalarSlots.length)
+            return outside('generated-scalar-correspondence');
+        let constructedContexts = 0;
+        if ('simple' in closure) {
+            assertSimpleExtensionConstruction(actual, closure);
+            if (closure.kind !== 'checked-simple-extension-construction' || closure.unresolved.length)
+                return outside('simple-extension-premises-unestablished');
+            if (closure.complex.frontier.scalarSlots.length || closure.simple.some(item => item.frontier.scalarSlots.length))
+                return outside('generated-scalar-correspondence');
+            // @why cos-ct-extends.1.5 asks for an in-principle relation, not replacement of the stored actual base.
+            //   Finite allocation keeps original identities and then binds TYPE/SCOPE edges unchanged. Each E owns
+            //   its new local attributes/uses. Its checked extension from anySimpleType and D's paired restriction
+            //   clauses 1-4 and 5.2 establish the two-step relation on D's unchanged effective properties. The exact
+            //   simple-extension spine, whole-actual and fresh-middle closure, and all typed/scalar debts are native
+            //   prerequisites of this authenticated receipt. Source/S4S/builtin/property restrictions above still apply.
+            constructedContexts = closure.simple.length;
+        }
+        check();
+        budget.chargeWork(256);
+        const receipt = Object.freeze({ kind: 'component-correspondence', basis: COMPONENT_CORRESPONDENCE,
+            scope: 'ordinary-source-components', interpretations: input.schemas.length, constructedContexts,
+            usage: Object.freeze({ ...budget.usage() }) });
+        issued.set(receipt, construction);
+        return receipt;
+    });
+}

package/dist/compiler/componentRecordProjection.d.ts

@@ -0,0 +1,109 @@
+import type { DirectOperationContract, DirectMessageRoot } from './directOperation.js';
+import { expandProjectionValue } from './directValues.js';
+import type { ComponentValueMapping, DirectApplicationValue, ProjectionValueReceipt } from './directValues.js';
+import type { ComponentDecodedXml, DirectCodecFailure, DirectXmlLimits } from './directCodec.js';
+import type { StandardSchemaElementDeclaration } from './standardSchemaComponents.js';
+import type { NamespaceConstraint } from './wildcardAlgebra.js';
+import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
+import type { ResolverUsage } from './semanticBudget.js';
+export interface ComponentRecordProjectionSpec {
+    readonly version: 'component-record-scope-v1';
+    readonly scope: 'records-with-declared-wrapper-scope';
+    /** Relative to the outer WSDL output element; the current family supports one direct wildcard boundary. */
+    readonly payloadPath: readonly ExpandedName[];
+    /** Relative to the companion output element; every step must select a unique declared native slot. */
+    readonly recordPath: readonly ExpandedName[];
+    /** Metadata is omitted; the wildcard is assessed in the explicit companion universe, not a merged wrapper universe. */
+    readonly opaqueExclusions: readonly Readonly<{
+        path: readonly ExpandedName[];
+        reason: 'standard-schema-metadata' | 'wrapper-declaration-universe';
+    }>[];
+}
+/** Explicit acknowledgement of the existing scope, with a record path only when it is a real choice.
+ * @since 1.1.7
+ */
+export interface ComponentRecordProjectionAssociation {
+    readonly scope: 'records-with-declared-wrapper-scope';
+    readonly recordPath?: readonly ExpandedName[];
+}
+export interface ComponentRecordProjection {
+    readonly kind: 'component-record-projection';
+    readonly version: 'component-record-scope-v1';
+    readonly direction: Readonly<{
+        kind: 'output';
+    }>;
+    readonly root: DirectMessageRoot;
+    readonly contextId: string;
+    readonly admitted: false;
+    readonly spec: ComponentRecordProjectionSpec;
+    readonly usage: ResolverUsage;
+}
+export interface ComponentRecordValue {
+    readonly kind: 'component-record-value';
+    readonly scope: 'records-with-declared-wrapper-scope';
+    readonly admitted: false;
+    readonly value: DirectApplicationValue;
+    readonly recordCount: number;
+    readonly companion: ProjectionValueReceipt;
+}
+export interface ComponentRecordDecodedXml {
+    readonly kind: 'component-record-decoded';
+    readonly admitted: false;
+    readonly payload: SyntaxElement;
+    readonly mapping: ComponentRecordProjection;
+    readonly validated: ComponentRecordValue;
+    readonly usage: ResolverUsage;
+}
+type Leaf = Readonly<{
+    kind: 'standard';
+    declaration: StandardSchemaElementDeclaration;
+} | {
+    kind: 'boundary';
+    namespace: NamespaceConstraint;
+}>;
+type Owned = Readonly<{
+    outer: DirectOperationContract;
+    companion: DirectOperationContract;
+    parser: ComponentValueMapping;
+    mapping: ComponentValueMapping;
+    leaves: readonly Leaf[];
+}>;
+/** Identity-only dispatch; inspecting an unowned object's fields cannot select this mapping profile. */
+export declare function isComponentRecordProjection(value: unknown): value is ComponentRecordProjection;
+/** Build an explicit mapping from independently qualified native contracts.
+ * @remarks The current wrapper family is a unit sequence of fixed standard metadata elements and one strict
+ *   wildcard. Native occurrence/EDC/UPA checks remain authoritative. The complete companion payload is retained;
+ *   record paths establish intended record declarations, not permission to discard other payload fields.
+ *   This is a buffered projection, not full-response XSD validation in a merged declaration universe or streaming.
+ * @returns An exact native projection or a specific unsupported/value/resource/cancellation result.
+ */
+export declare function createComponentRecordProjection(outer: DirectOperationContract, companion: DirectOperationContract, supplied: ComponentRecordProjectionSpec | ComponentRecordProjectionAssociation, options?: Readonly<{
+    signal?: AbortSignal;
+}>): ComponentRecordProjection | DirectCodecFailure;
+/** Native projection identity and exact outer contract are checked before reading projection fields. */
+export declare function inspectComponentRecordProjection(projection: ComponentRecordProjection, outer?: DirectOperationContract): Owned;
+export declare function inspectComponentRecordValue(value: ComponentRecordValue, projection: ComponentRecordProjection): ComponentRecordValue;
+/** Revalidate the projected application value, including after JSON serialization.
+ * @remarks This uses the exact companion's existing inverse and scalar/structure owners. It establishes only
+ *   projected-value validity; it cannot reconstruct or certify omitted wrapper metadata or SOAP protocol state.
+ */
+export declare function validateComponentRecordApplication(projection: ComponentRecordProjection, application: unknown, options?: Readonly<{
+    signal?: AbortSignal;
+    maxText?: number;
+    maxItems?: number;
+}>): ReturnType<typeof expandProjectionValue>;
+/** Decode once and validate the declared wrapper plus its explicitly selected companion payload.
+ * @remarks The complete companion value survives; only declared standard metadata is omitted. This function
+ *   does not validate SOAP protocol grammar itself. Its protocol selector can choose only this projection or
+ *   an actual declared fault mapping of the outer contract, always on nodes from the same parse.
+ */
+export declare function decodeComponentRecordXml(outer: DirectOperationContract, projection: ComponentRecordProjection, bytes: Uint8Array, options?: Readonly<{
+    signal?: AbortSignal;
+    limits?: DirectXmlLimits;
+    uri?: string;
+    selectPayload?: (root: SyntaxElement) => {
+        payload: SyntaxElement;
+        mapping: ComponentRecordProjection | ComponentValueMapping;
+    };
+}>): ComponentRecordDecodedXml | ComponentDecodedXml | DirectCodecFailure;
+export {};

package/dist/compiler/componentRecordProjection.js

@@ -0,0 +1,319 @@
+/** Explicit buffered companion-record projection; wrapper and record source contexts never merge. */
+import { inspectDirectOperation } from './directOperation.js';
+import { createComponentValueMapping, inspectComponentValueMapping, expandProjectionValue } from './directValues.js';
+import { observeComponentXml, assertComponentObservedPayload, assessObservedComponentPayload } from './directCodec.js';
+import { deriveActualComplexContent } from './complexTypeContent.js';
+import { prepareSemanticParticleView } from './particleSemanticView.js';
+import { checkDeclaredParticleLegality } from './particleLocalAssessment.js';
+import { assessSourceAttributeUses } from './schemaAttributeUses.js';
+import { assessStandardSchemaElement } from './standardSchemaComponents.js';
+import { namespaceAllows } from './wildcardAlgebra.js';
+import { directDataOwnership } from './directExecutionPolicy.js';
+import { DataOwnershipLimitError } from './dataOwnership.js';
+import { isXmlNCName, syntaxElements } from '../loader/orderedSyntax.js';
+const issued = new WeakMap();
+const values = new WeakMap();
+/** Identity-only dispatch; inspecting an unowned object's fields cannot select this mapping profile. */
+export function isComponentRecordProjection(value) {
+    return !!value && typeof value === 'object' && issued.has(value);
+}
+class ScopeStop extends Error {
+    kind;
+    rule;
+    constructor(kind, rule) {
+        super(rule);
+        this.kind = kind;
+        this.rule = rule;
+    }
+}
+const same = (a, b) => a.namespace === b.namespace && a.local === b.local;
+const ownKeys = (value, keys) => Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
+/** Build an explicit mapping from independently qualified native contracts.
+ * @remarks The current wrapper family is a unit sequence of fixed standard metadata elements and one strict
+ *   wildcard. Native occurrence/EDC/UPA checks remain authoritative. The complete companion payload is retained;
+ *   record paths establish intended record declarations, not permission to discard other payload fields.
+ *   This is a buffered projection, not full-response XSD validation in a merged declaration universe or streaming.
+ * @returns An exact native projection or a specific unsupported/value/resource/cancellation result.
+ */
+export function createComponentRecordProjection(outer, companion, supplied, options = {}) {
+    const { context } = inspectDirectOperation(outer);
+    inspectDirectOperation(companion);
+    const { budget } = context;
+    const check = () => { budget.chargeWork(); if (options.signal?.aborted)
+        throw new ScopeStop('cancelled', 'cooperative-cancellation'); };
+    const stop = rule => { throw new ScopeStop('unsupported', rule); };
+    const failure = (kind, rule) => Object.freeze({ kind, rule, usage: Object.freeze({ ...budget.usage() }) });
+    try {
+        const result = budget.guard(() => {
+            check();
+            if (outer.basis !== 'native-component-premises-v1' || companion.basis !== 'native-component-premises-v1'
+                || outer.correspondence !== 'dated-XSD-2004-components-v1' || companion.correspondence !== 'dated-XSD-2004-components-v1')
+                stop('component-record-source-authority');
+            const requested = directDataOwnership(budget).freeze(directDataOwnership(budget).snapshot(supplied, check));
+            const association = requested && typeof requested === 'object' && !Object.hasOwn(requested, 'version');
+            if (association && (requested.scope !== 'records-with-declared-wrapper-scope'
+                || !ownKeys(requested, Object.hasOwn(requested, 'recordPath') ? ['scope', 'recordPath'] : ['scope'])))
+                throw new ScopeStop('value-invalid', 'explicit-component-record-scope');
+            let spec = association ? { version: 'component-record-scope-v1', scope: requested.scope,
+                payloadPath: [companion.output.element.name], recordPath: requested.recordPath ?? [], opaqueExclusions: [] } : requested;
+            const validName = (name) => name && typeof name === 'object' && ownKeys(name, ['namespace', 'local'])
+                && typeof name.namespace === 'string' && typeof name.local === 'string' && isXmlNCName(name.local);
+            const path = (names) => Array.isArray(names) && names.length > 0 && names.every(validName);
+            if (!spec || typeof spec !== 'object' || !ownKeys(spec, ['version', 'scope', 'payloadPath', 'recordPath', 'opaqueExclusions'])
+                || spec.version !== 'component-record-scope-v1' || spec.scope !== 'records-with-declared-wrapper-scope'
+                || !path(spec.payloadPath) || spec.payloadPath.length !== 1 || !(association && !Object.hasOwn(requested, 'recordPath') || path(spec.recordPath))
+                || !Array.isArray(spec.opaqueExclusions) || !spec.opaqueExclusions.every(item => item && typeof item === 'object'
+                && ownKeys(item, ['path', 'reason']) && path(item.path) && item.path.length === 1
+                && ['standard-schema-metadata', 'wrapper-declaration-universe'].includes(item.reason)))
+                throw new ScopeStop('value-invalid', 'explicit-component-record-scope');
+            if (!same(spec.payloadPath[0], companion.output.element.name))
+                stop('companion-output-payload-path');
+            const parser = createComponentValueMapping(outer, { kind: 'input' }, options);
+            if (parser.kind !== 'component-mapping')
+                return parser;
+            const mapping = createComponentValueMapping(companion, { kind: 'output' }, options);
+            if (mapping.kind !== 'component-mapping')
+                return mapping;
+            const projection = inspectComponentValueMapping(mapping, companion).projection;
+            const records = new Map(projection.records.map(record => [record.type.id, record]));
+            if (association && !Object.hasOwn(requested, 'recordPath')) {
+                const candidates = [];
+                let recursive = false;
+                const pending = [
+                    { value: projection.root, prefix: [], ancestors: new Set() },
+                ];
+                while (pending.length) {
+                    check();
+                    const { value, prefix, ancestors } = pending.pop();
+                    if (value.kind !== 'record')
+                        continue;
+                    if (ancestors.has(value.type)) {
+                        recursive = true;
+                        continue;
+                    }
+                    const record = records.get(value.type);
+                    if (!record)
+                        stop('record-path-native-record');
+                    const next = new Set(ancestors);
+                    next.add(value.type);
+                    for (const slot of record.slots) {
+                        check();
+                        const path = [...prefix, slot.element.name];
+                        if (slot.value.kind === 'record' && slot.particle.occurs.max !== '1')
+                            candidates.push(path);
+                        pending.push({ value: slot.value, prefix: path, ancestors: next });
+                    }
+                }
+                if (!recursive && !candidates.length)
+                    stop('record-path-complex-repeated-declaration');
+                if (recursive || candidates.length !== 1)
+                    stop(`ambiguous-record-path: supply recordPath selecting one repeated complex declaration; candidates=${JSON.stringify(candidates)}; recursive=${recursive}`);
+                spec = { ...spec, recordPath: candidates[0] };
+            }
+            let value = projection.root;
+            for (let index = 0; index < spec.recordPath.length; index++) {
+                check();
+                if (value.kind !== 'record')
+                    stop('record-path-record-parent');
+                const record = records.get(value.type);
+                if (!record)
+                    stop('record-path-native-record');
+                const slots = record.slots.filter(slot => { check(); return same(slot.element.name, spec.recordPath[index]); });
+                if (slots.length !== 1)
+                    stop('record-path-unique-declaration');
+                value = slots[0].value;
+                if (index === spec.recordPath.length - 1 && (value.kind !== 'record' || slots[0].particle.occurs.max === '1'))
+                    stop('record-path-complex-repeated-declaration');
+            }
+            const root = outer.output.element;
+            if (root.nillable || root.abstract || root.value || root.substitutionGroup)
+                stop('record-wrapper-declaration');
+            const type = context.resolve(root.type);
+            if (type.kind !== 'found' || type.node.kind !== 'complexType' || type.node.abstract || type.node.mixed)
+                stop('record-wrapper-complex-type');
+            const attributes = assessSourceAttributeUses(context, type.node.id);
+            if (attributes.kind === 'resource-limit')
+                return failure('resource-limit', 'record-wrapper-attributes');
+            if (attributes.kind !== 'checked' || attributes.value.wildcard || attributes.value.attributes.length)
+                stop('record-wrapper-attribute-scope');
+            const content = deriveActualComplexContent(context, type.node.id);
+            if (content.kind === 'resource-limit')
+                return failure('resource-limit', 'record-wrapper-content');
+            if (content.kind !== 'checked' || content.view.content.kind !== 'element-only')
+                stop('record-wrapper-content');
+            const prepared = prepareSemanticParticleView(context, content.view, 'declared');
+            if (prepared.kind === 'resource-limit')
+                return failure('resource-limit', 'record-wrapper-particle');
+            if (prepared.kind !== 'checked')
+                stop('record-wrapper-particle');
+            const legal = checkDeclaredParticleLegality(context, prepared.view);
+            if (legal.kind === 'resource-limit')
+                return failure('resource-limit', 'record-wrapper-particle-legality');
+            if (legal.kind !== 'checked' || !legal.value)
+                stop('record-wrapper-particle-legality');
+            const leaves = [], pending = [prepared.view.root];
+            let boundaries = 0;
+            while (pending.length) {
+                check();
+                const particle = pending.pop();
+                if (particle.occurs.min !== '1' || particle.occurs.max !== '1')
+                    stop('record-wrapper-unit-occurrence');
+                if (particle.kind === 'sequence')
+                    for (let index = particle.children.length - 1; index >= 0; index--) {
+                        check();
+                        pending.push(particle.children[index]);
+                    }
+                else if (particle.standardElement)
+                    leaves.push(Object.freeze({ kind: 'standard', declaration: particle.standardElement }));
+                else if (particle.kind === 'any' && particle.wildcard?.processContents === 'strict') {
+                    if (++boundaries > 1 || !namespaceAllows(particle.wildcard.namespace, spec.payloadPath[0].namespace, budget.chargeWork))
+                        stop('record-wrapper-wildcard-boundary');
+                    leaves.push(Object.freeze({ kind: 'boundary', namespace: particle.wildcard.namespace }));
+                }
+                else
+                    stop('record-wrapper-terminal-scope');
+            }
+            if (boundaries !== 1)
+                stop('record-wrapper-one-boundary');
+            const metadata = leaves.filter((leaf) => leaf.kind === 'standard');
+            if (association)
+                spec = { ...spec, opaqueExclusions: [
+                        ...metadata.map(leaf => ({ path: [leaf.declaration.name], reason: 'standard-schema-metadata' })),
+                        { path: spec.payloadPath, reason: 'wrapper-declaration-universe' },
+                    ] };
+            const exclusions = spec.opaqueExclusions.filter(item => item.reason === 'standard-schema-metadata');
+            const universes = spec.opaqueExclusions.filter(item => item.reason === 'wrapper-declaration-universe');
+            if (metadata.length !== exclusions.length || metadata.some(leaf => exclusions.filter(item => same(item.path[0], leaf.declaration.name)).length !== 1)
+                || universes.length !== 1 || !same(universes[0].path[0], spec.payloadPath[0]))
+                stop('record-wrapper-explicit-exclusions');
+            check();
+            const result = Object.freeze({ kind: 'component-record-projection', version: 'component-record-scope-v1',
+                direction: Object.freeze({ kind: 'output' }), root: outer.output, contextId: outer.contextId, admitted: false, spec: directDataOwnership(budget).freeze(spec),
+                usage: Object.freeze({ ...budget.usage() }) });
+            issued.set(result, Object.freeze({ outer, companion, parser, mapping, leaves: Object.freeze(leaves) }));
+            return result;
+        });
+        return result.kind === 'resource-limit' && !('rule' in result) ? failure('resource-limit', 'record-projection-budget') : result;
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return failure('resource-limit', 'record-projection-budget');
+        if (error instanceof DataOwnershipLimitError)
+            return failure('resource-limit', error.message);
+        if (error instanceof ScopeStop)
+            return failure(error.kind, error.rule);
+        throw error;
+    }
+}
+/** Native projection identity and exact outer contract are checked before reading projection fields. */
+export function inspectComponentRecordProjection(projection, outer) {
+    const owned = issued.get(projection);
+    if (!owned || outer !== undefined && owned.outer !== outer)
+        throw new TypeError('Native matching component record projection required');
+    inspectDirectOperation(owned.outer);
+    inspectDirectOperation(owned.companion);
+    return owned;
+}
+export function inspectComponentRecordValue(value, projection) {
+    inspectComponentRecordProjection(projection);
+    if (values.get(value) !== projection)
+        throw new TypeError('Native matching component record value required');
+    return value;
+}
+/** Revalidate the projected application value, including after JSON serialization.
+ * @remarks This uses the exact companion's existing inverse and scalar/structure owners. It establishes only
+ *   projected-value validity; it cannot reconstruct or certify omitted wrapper metadata or SOAP protocol state.
+ */
+export function validateComponentRecordApplication(projection, application, options = {}) {
+    const owned = inspectComponentRecordProjection(projection), { context } = inspectDirectOperation(owned.companion);
+    return expandProjectionValue(context, owned.mapping.root.element, application, options);
+}
+/** Decode once and validate the declared wrapper plus its explicitly selected companion payload.
+ * @remarks The complete companion value survives; only declared standard metadata is omitted. This function
+ *   does not validate SOAP protocol grammar itself. Its protocol selector can choose only this projection or
+ *   an actual declared fault mapping of the outer contract, always on nodes from the same parse.
+ */
+export function decodeComponentRecordXml(outer, projection, bytes, options = {}) {
+    const owned = inspectComponentRecordProjection(projection, outer), { context } = inspectDirectOperation(outer), { budget } = context;
+    const check = () => { budget.chargeWork(); if (options.signal?.aborted)
+        throw new ScopeStop('cancelled', 'cooperative-cancellation'); };
+    const failure = (kind, rule) => Object.freeze({ kind, rule, usage: Object.freeze({ ...budget.usage() }) });
+    try {
+        const result = budget.guard(() => {
+            check();
+            const observation = observeComponentXml(outer, owned.parser, bytes, options);
+            if (observation.kind !== 'observed-component-xml')
+                return observation;
+            const selected = options.selectPayload?.(observation.root) ?? { payload: observation.root, mapping: projection };
+            assertComponentObservedPayload(observation, selected.payload, check);
+            if (selected.mapping !== projection) {
+                const { mapping } = inspectComponentValueMapping(selected.mapping, outer);
+                if (mapping.direction.kind !== 'fault')
+                    throw new TypeError('Record projection selection requires this output or a declared fault');
+                return assessObservedComponentPayload(outer, mapping, observation, selected.payload, options);
+            }
+            const wrapper = selected.payload;
+            if (!same(wrapper.name, outer.output.element.name))
+                throw new ScopeStop('mismatch', 'record-wrapper-root');
+            if (wrapper.attributes.length || wrapper.children.some(node => node.kind === 'text' && /[^\t\r\n ]/.test(node.value)))
+                throw new ScopeStop('mismatch', 'record-wrapper-attributes-or-text');
+            const children = syntaxElements(wrapper);
+            if (children.length !== owned.leaves.length)
+                throw new ScopeStop('mismatch', 'record-wrapper-child-count');
+            let payload;
+            for (let index = 0; index < owned.leaves.length; index++) {
+                check();
+                const leaf = owned.leaves[index], child = children[index];
+                if (leaf.kind === 'standard') {
+                    if (!same(child.name, leaf.declaration.name))
+                        throw new ScopeStop('mismatch', 'record-wrapper-standard-order');
+                    const assessed = assessStandardSchemaElement(leaf.declaration, child, budget, { signal: options.signal, check });
+                    if (assessed.kind !== 'schema-element-instance')
+                        return failure(assessed.kind, assessed.kind === 'resource-limit' ? 'record-standard-budget' : assessed.rule);
+                    if (assessed.remaining.length)
+                        throw new ScopeStop('unsupported', 'record-standard-instance-obligations');
+                }
+                else {
+                    if (!same(child.name, projection.spec.payloadPath[0]) || !namespaceAllows(leaf.namespace, child.name.namespace, budget.chargeWork))
+                        throw new ScopeStop('mismatch', 'record-wrapper-companion-boundary');
+                    payload = child;
+                }
+            }
+            if (!payload)
+                throw new TypeError('Native record boundary unavailable');
+            const decoded = assessObservedComponentPayload(owned.companion, owned.mapping, observation, payload, options);
+            if (decoded.kind !== 'component-decoded')
+                return decoded;
+            const recordCount = countRecords(observation, payload, projection.spec.recordPath, check);
+            const validated = Object.freeze({ kind: 'component-record-value', scope: 'records-with-declared-wrapper-scope',
+                admitted: false, value: decoded.validated.value, recordCount, companion: decoded.validated });
+            values.set(validated, projection);
+            check();
+            return Object.freeze({ kind: 'component-record-decoded', admitted: false, payload: wrapper, mapping: projection,
+                validated, usage: Object.freeze({ ...budget.usage() }) });
+        });
+        return result.kind === 'resource-limit' && !('rule' in result) ? failure('resource-limit', 'record-projection-budget') : result;
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return failure('resource-limit', 'record-projection-budget');
+        if (error instanceof ScopeStop)
+            return failure(error.kind, error.rule);
+        throw error;
+    }
+}
+function countRecords(observation, payload, path, check) {
+    assertComponentObservedPayload(observation, payload, check);
+    let current = [payload];
+    for (const name of path) {
+        const next = [];
+        for (const parent of current)
+            for (const child of syntaxElements(parent)) {
+                check();
+                if (same(child.name, name))
+                    next.push(child);
+            }
+        current = next;
+    }
+    return current.length;
+}

package/dist/compiler/componentSoapPreparation.d.ts

@@ -0,0 +1,20 @@
+import type { DirectOperationContract } from './directOperation.js';
+import type { ExpandedName } from '../loader/orderedSyntax.js';
+/** Own closed metadata for one invocation; runtime reconstruction never consumes this object.
+ * @since 1.1.7
+ * @constraints Every action and selection is checked against authentic native source before reuse.
+ */
+export declare class ComponentSoapPreparation {
+    #private;
+    /** Prepare one source/service/binding within this invocation.
+     * @param contract Fresh native operation identity.
+     * @param selection Service/port choice checked before reuse.
+     * @param check Cancellation and resource checks owned by this invocation.
+     * @returns Resolves after closed metadata preparation; dependency objects remain private.
+     * @throws For foreign handles, unsupported selection, cancellation or bootstrap failures.
+     */
+    prepare(contract: DirectOperationContract, selection: {
+        service: ExpandedName;
+        port: string;
+    }, check: () => void): Promise<void>;
+}

package/dist/compiler/componentSoapPreparation.js

@@ -0,0 +1,36 @@
+/** Invocation-local SOAP preparation ownership without exposing dependency metadata types.
+ * @since 1.1.7
+ */
+import { inspectDirectOperation } from './directOperation.js';
+import { prepareComponentSoapWsdl, validateComponentSoapSelection } from './directSoapSource.js';
+/** Own closed metadata for one invocation; runtime reconstruction never consumes this object.
+ * @since 1.1.7
+ * @constraints Every action and selection is checked against authentic native source before reuse.
+ */
+export class ComponentSoapPreparation {
+    #sources = new WeakMap();
+    /** Prepare one source/service/binding within this invocation.
+     * @param contract Fresh native operation identity.
+     * @param selection Service/port choice checked before reuse.
+     * @param check Cancellation and resource checks owned by this invocation.
+     * @returns Resolves after closed metadata preparation; dependency objects remain private.
+     * @throws For foreign handles, unsupported selection, cancellation or bootstrap failures.
+     */
+    async prepare(contract, selection, check) {
+        const { source } = inspectDirectOperation(contract);
+        validateComponentSoapSelection(contract, selection, check);
+        const key = JSON.stringify([selection.service, selection.port, contract.selector.binding]);
+        let entries = this.#sources.get(source);
+        if (!entries) {
+            entries = new Map();
+            this.#sources.set(source, entries);
+        }
+        let prepared = entries.get(key);
+        if (!prepared) {
+            prepared = prepareComponentSoapWsdl(contract, selection, check);
+            entries.set(key, prepared);
+        }
+        await prepared;
+        check();
+    }
+}