@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/directCodec.js

@@ -3,34 +3,46 @@ import { directDataOwnership, directLimit } from './directExecutionPolicy.js';
 import { checkSemanticBudget } from './semanticBudget.js';
 import { DataOwnershipLimitError } from './dataOwnership.js';
 import { types } from 'node:util';
-import { inspectDirectOperation } from './directOperation.js';
-import { inspectDirectValueMapping, expandDirectValue, assessDirectScalars } from './directValues.js';
-import { matchDirectOperation } from './directStructure.js';
+import { inspectDirectOperation, isRpcMessageRoot } from './directOperation.js';
+import { inspectDirectValueMapping, expandDirectValue, assessDirectScalars, inspectComponentValueMapping, expandProjectionValue, assessProjectionScalars } from './directValues.js';
+import { matchDirectOperation, matchDirectProjection } from './directStructure.js';
 import { parseOrderedSyntax, SchemaLoadingError, XML_NAMESPACE } from '../loader/orderedSyntax.js';
+import { isXmlNamespaceBinding } from './directStructurePlan.js';
+import { expandRpcStrings, readRpcStrings } from './rpcStringValues.js';
+import { expandRpcTyped, readRpcTyped } from './rpcTypedValues.js';
 export const DIRECT_XML_LIMITS = Object.freeze({ maxBytes: 1024 * 1024, maxDepth: 256, maxNodes: 100_000, maxText: 1024 * 1024 });
+const componentObservations = new WeakSet();
 class Stop extends Error {
     kind;
     rule;
-    constructor(kind, rule) {
+    source;
+    constructor(kind, rule, source) {
         super(rule);
         this.kind = kind;
         this.rule = rule;
+        this.source = source;
     }
 }
-function run(contract, supplied, options, work) {
+const directProfile = Object.freeze({ version: 'direct-values-v1', basis: 'native-direct-premises-v1',
+    correspondence: 'dated-XSD-2004-direct-v1', rule: 'direct-codec-version' });
+const componentProfile = Object.freeze({ version: 'component-values-v1', basis: 'native-component-premises-v1',
+    correspondence: 'dated-XSD-2004-components-v1', rule: 'component-codec-version' });
+function runMapping(contract, supplied, options, profile, inspect, work) {
     // Identity before all property reads, including version checks.
-    const mapping = inspectDirectValueMapping(supplied, contract);
+    const mapping = inspect(supplied, contract);
     const { budget } = inspectDirectOperation(contract).context;
     const check = () => { checkSemanticBudget(budget); if (options.signal?.aborted)
         throw new Stop('cancelled', 'cooperative-cancellation'); };
     try {
         const result = budget.guard(() => {
             check();
-            if (mapping.version !== 'direct-values-v1' || mapping.contextId !== contract.contextId
-                || contract.basis !== 'native-direct-premises-v1' || contract.correspondence !== 'dated-XSD-2004-direct-v1'
-                || contract.binding.version !== '1.1' || contract.binding.style !== 'document' || contract.binding.use !== 'literal'
+            const rpc = profile === componentProfile && (mapping.version === 'component-rpc-string-values-v1' || mapping.version === 'component-rpc-typed-values-v1') && isRpcMessageRoot(mapping.root)
+                && contract.binding.style === 'rpc' && contract.binding.use === 'encoded' && contract.binding.encoding === 'http://schemas.xmlsoap.org/soap/encoding/';
+            if ((!rpc && mapping.version !== profile.version) || mapping.contextId !== contract.contextId
+                || contract.basis !== profile.basis || contract.correspondence !== profile.correspondence
+                || contract.binding.version !== '1.1' || !rpc && (contract.binding.style !== 'document' || contract.binding.use !== 'literal')
                 || contract.binding.transport !== 'http://schemas.xmlsoap.org/soap/http')
-                throw new Stop('unsupported', 'direct-codec-version');
+                throw new Stop('unsupported', profile.rule);
             const direction = mapping.direction;
             const root = direction.kind === 'fault' ? contract.faults.find(f => {
                 check();
@@ -72,7 +84,8 @@ function run(contract, supplied, options, work) {
         if (error instanceof DataOwnershipLimitError)
             return { kind: 'resource-limit', rule: error.message, usage: budget.usage() };
         if (error instanceof Stop)
-            return Object.freeze({ kind: error.kind, rule: error.rule, usage: Object.freeze({ ...budget.usage() }) });
+            return Object.freeze({ kind: error.kind, rule: error.rule,
+                ...(error.source ? { source: error.source, payloadPath: error.source.path } : {}), usage: Object.freeze({ ...budget.usage() }) });
         if (error instanceof SchemaLoadingError)
             return Object.freeze({ kind: error.category === 'invalid-schema' ? 'xml-invalid'
                     : error.category === 'resource-limit' ? 'resource-limit' : 'unsupported', rule: error.message, source: error.source,
@@ -80,103 +93,273 @@ function run(contract, supplied, options, work) {
         throw error;
     }
 }
+function run(contract, mapping, options, work) {
+    return runMapping(contract, mapping, options, directProfile, inspectDirectValueMapping, work);
+}
+function runComponent(contract, mapping, options, work) {
+    return runMapping(contract, mapping, options, componentProfile, (value, owner) => inspectComponentValueMapping(value, owner).mapping, work);
+}
+/** Serialize only native inverse output; source names and values have already passed their native owners. */
+function emitObservedXml(payload, { budget, limits, check }) {
+    const pieces = [];
+    let byteLength = 0, nodes = 0, textUnits = 0, nextPrefix = 0;
+    const prefixes = new Map();
+    const append = (text) => {
+        check();
+        const size = Buffer.byteLength(text, 'utf8');
+        if (size > limits.maxBytes - byteLength)
+            throw new Stop('resource-limit', 'XML byte limit');
+        byteLength += size;
+        pieces.push(text);
+    };
+    const escape = (text, attribute = false) => {
+        check();
+        return text.replace(/[&<>\r"\t\n]/g, c => c === '&' ? '&amp;' : c === '<' ? '&lt;' : c === '>' ? '&gt;'
+            : c === '\r' ? '&#13;' : attribute && c === '"' ? '&quot;' : attribute && c === '\t' ? '&#9;'
+                : attribute && c === '\n' ? '&#10;' : c);
+    };
+    const prefixFor = (namespace) => {
+        if (!namespace)
+            return '';
+        if (namespace === 'http://www.w3.org/2000/xmlns/')
+            throw new Stop('unsupported', 'namespace-declaration-as-data');
+        let prefix = namespace === XML_NAMESPACE ? 'xml' : prefixes.get(namespace);
+        if (namespace && prefix === undefined) {
+            prefix = `n${nextPrefix++}`;
+            prefixes.set(namespace, prefix);
+        }
+        return prefix;
+    };
+    const tasks = [{ kind: 'element', node: payload, depth: 1 }];
+    while (tasks.length) {
+        check();
+        const task = tasks.pop();
+        if (task.kind === 'close') {
+            append(`</${task.name}>`);
+            continue;
+        }
+        budget.reserveNodes(1);
+        if (task.kind === 'text') {
+            if (++nodes > limits.maxNodes || task.value.length > limits.maxText - textUnits)
+                throw new Stop('resource-limit', 'XML node/text limit');
+            textUnits += task.value.length;
+            append(escape(task.value));
+            continue;
+        }
+        const { node, depth } = task;
+        if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+            throw new Stop('resource-limit', 'XML node/depth limit');
+        const declarations = new Map();
+        const protectedScope = Object.hasOwn(node.namespaces, 'xml');
+        const scope = Object.assign(Object.create(null), task.scope ?? { xml: XML_NAMESPACE, '': '' });
+        if (protectedScope) {
+            for (const prefix of budget.sorted(Object.keys(node.namespaces), (a, b) => budget.compareText(a, b))) {
+                check();
+                const namespace = node.namespaces[prefix];
+                if (!isXmlNamespaceBinding(prefix, namespace))
+                    throw new Stop('value-invalid', 'namespace-binding', node.source);
+                if (prefix !== 'xml' && scope[prefix] !== namespace)
+                    declarations.set(prefix, namespace);
+                scope[prefix] = namespace;
+            }
+        }
+        const qualified = (namespace, local, attribute = false) => {
+            if (protectedScope) {
+                if (!namespace) {
+                    if (!attribute && scope[''])
+                        throw new Stop('value-invalid', 'no-namespace-element-default-conflict', node.source);
+                    return local;
+                }
+                const prefix = budget.sorted(Object.keys(scope), (a, b) => budget.compareText(a, b))
+                    .find(prefix => (!attribute || prefix !== '') && scope[prefix] === namespace);
+                if (prefix === undefined)
+                    throw new Stop('value-invalid', attribute ? 'attribute-namespace-prefix-required' : 'element-namespace-prefix-required', node.source);
+                return prefix ? `${prefix}:${local}` : local;
+            }
+            if (!namespace) {
+                if (!attribute && scope['']) {
+                    declarations.set('', '');
+                    scope[''] = '';
+                }
+                return local;
+            }
+            const prefix = prefixFor(namespace);
+            let selected = prefix;
+            while (scope[selected] !== undefined && scope[selected] !== namespace)
+                selected = `n${nextPrefix++}`;
+            if (selected && selected !== 'xml') {
+                declarations.set(selected, namespace);
+                scope[selected] = namespace;
+            }
+            return selected ? `${selected}:${local}` : local;
+        };
+        const name = qualified(node.name.namespace, node.name.local), attributes = [];
+        for (const attribute of node.attributes) {
+            check();
+            if (attribute.name.namespace === '' && attribute.name.local === 'xmlns')
+                throw new Stop('unsupported', 'namespace-declaration-as-data');
+            attributes.push(` ${qualified(attribute.name.namespace, attribute.name.local, true)}="${escape(attribute.value, true)}"`);
+        }
+        // @why Bind each used prefix at this element; sibling discovery never makes a prefix in scope elsewhere.
+        append(`<${name}`);
+        for (const [prefix, namespace] of declarations)
+            append(` xmlns${prefix ? ':' + prefix : ''}="${escape(namespace, true)}"`);
+        for (const attribute of attributes)
+            append(attribute);
+        append('>');
+        tasks.push({ kind: 'close', name });
+        for (let i = node.children.length - 1; i >= 0; i--) {
+            check();
+            const child = node.children[i];
+            tasks.push(child.kind === 'element' ? { kind: 'element', node: child, depth: depth + 1, scope } : { kind: 'text', value: child.value });
+        }
+    }
+    // Actual output bytes were bounded by append; bytes are caller-owned data, not authority.
+    check();
+    const bytes = Buffer.from(pieces.join(''), 'utf8');
+    check();
+    return bytes;
+}
 /** Validate fresh values using the delivered inverse, then emit deterministic UTF-8. */
 export function encodeDirectXml(contract, mapping, application, options = {}) {
-    return run(contract, mapping, options, (owned, { budget, limits, check }) => {
+    return run(contract, mapping, options, (owned, session) => {
+        const { budget, limits } = session;
         const expanded = expandDirectValue(contract, owned, application, { ...options, maxText: Math.min(limits.maxText, limits.maxBytes), maxItems: Math.min(limits.maxNodes, limits.maxBytes) });
         if (expanded.kind !== 'direct-expanded')
             return expanded;
-        const pieces = [];
-        let byteLength = 0, nodes = 0, textUnits = 0, nextPrefix = 0;
-        const prefixes = new Map();
-        const append = (text) => {
-            check();
-            const size = Buffer.byteLength(text, 'utf8');
-            if (size > limits.maxBytes - byteLength)
-                throw new Stop('resource-limit', 'XML byte limit');
-            byteLength += size;
-            pieces.push(text);
-        };
-        const escape = (text, attribute = false) => {
-            check();
-            return text.replace(/[&<>\r"\t\n]/g, c => c === '&' ? '&amp;' : c === '<' ? '&lt;' : c === '>' ? '&gt;'
-                : c === '\r' ? '&#13;' : attribute && c === '"' ? '&quot;' : attribute && c === '\t' ? '&#9;'
-                    : attribute && c === '\n' ? '&#10;' : c);
-        };
-        const emit = (node, depth) => {
-            check();
-            budget.reserveNodes(1);
-            if (++nodes > limits.maxNodes || depth > limits.maxDepth)
-                throw new Stop('resource-limit', 'XML node/depth limit');
-            const namespace = node.name.namespace;
-            let prefix = namespace === XML_NAMESPACE ? 'xml' : prefixes.get(namespace);
-            if (namespace && prefix === undefined) {
-                prefix = `n${nextPrefix++}`;
-                prefixes.set(namespace, prefix);
-            }
-            // Bind at each use: a prefix first encountered on one sibling is not in
-            // scope at its next sibling. Never use a default namespace, so local
-            // unqualified children need no inherited-default reset.
-            const declaration = namespace && prefix !== 'xml' ? ` xmlns:${prefix}="${escape(namespace, true)}"` : '';
-            const name = prefix ? `${prefix}:${node.name.local}` : node.name.local;
-            append(`<${name}${declaration}>`);
-            for (const child of node.children) {
-                check();
-                if (child.kind === 'element')
-                    emit(child, depth + 1);
-                else {
-                    budget.reserveNodes(1);
-                    if (++nodes > limits.maxNodes || child.value.length > limits.maxText - textUnits)
-                        throw new Stop('resource-limit', 'XML node/text limit');
-                    textUnits += child.value.length;
-                    append(escape(child.value));
-                }
-            }
-            append(`</${name}>`);
-        };
-        emit(expanded.payload, 1);
-        // Actual output bytes were bounded by append; bytes are caller-owned data, not authority.
-        check();
-        const bytes = Buffer.from(pieces.join(''), 'utf8');
-        check();
+        const bytes = emitObservedXml(expanded.payload, session);
         return Object.freeze({ kind: 'direct-encoded', admitted: false, encoding: 'utf-8',
             bytes, expanded, usage: Object.freeze({ ...budget.usage() }) });
     });
 }
+/** Encode a component-qualified structured operation direction through the same native inverse and XML writer.
+ * @remarks Mapping/source authority is checked before values. This supplies XML bytes only, not policy enforcement or dispatch.
+ * @returns Native-validated UTF-8 output or explicit scalar/value/unsupported/cancellation/resource failure.
+ */
+export function encodeComponentXml(contract, mapping, application, options = {}) {
+    return runComponent(contract, mapping, options, (owned, session) => {
+        const { context } = inspectDirectOperation(contract), { budget, limits } = session;
+        if (isRpcMessageRoot(owned.root)) {
+            const control = { ...session, fail: (kind, rule, node) => { throw new Stop(kind, rule, node?.source); } };
+            const { rpcParts } = inspectComponentValueMapping(owned, contract);
+            const result = rpcParts ? expandRpcTyped(context, owned.root, rpcParts, application, control) : expandRpcStrings(owned.root, application, control);
+            const validated = { kind: rpcParts ? 'rpc-typed-value' : 'rpc-string-value', admitted: false, value: result.value, usage: budget.usage() };
+            const expanded = { kind: rpcParts ? 'rpc-typed-expanded' : 'rpc-string-expanded', admitted: false, payload: result.payload, validated, usage: budget.usage() };
+            directDataOwnership(budget).freeze(expanded);
+            const bytes = emitObservedXml(result.payload, session);
+            return Object.freeze({ kind: 'component-encoded', admitted: false, encoding: 'utf-8', bytes, expanded, mapping: owned, usage: budget.usage() });
+        }
+        // @why Application items include attributes; XML syntax-node/text caps count elements and character data.
+        //   Encoded bytes bound inverse input capacity without treating those different counters as equal.
+        const expanded = expandProjectionValue(context, owned.root.element, application, { ...options,
+            maxText: limits.maxBytes, maxItems: limits.maxBytes }, owned);
+        if (expanded.kind !== 'projection-expanded')
+            return expanded;
+        const bytes = emitObservedXml(expanded.payload, session);
+        return Object.freeze({ kind: 'component-encoded', admitted: false, encoding: 'utf-8',
+            bytes, expanded, mapping: owned, usage: Object.freeze({ ...budget.usage() }) });
+    });
+}
+/** Retain the shared byte-copy, XML-version, entity and explicit capacity boundaries for both profiles. */
+function parseObservedXml(bytes, { budget, limits, check }, sourceUri, componentResponseEncoding) {
+    if (!types.isUint8Array(bytes) || types.isProxy(bytes))
+        throw new TypeError('XML requires Uint8Array bytes');
+    // Use native internal-slot access, avoiding subclass/own length, buffer and
+    // iterator getters. Shared backing stores are outside the data-only contract.
+    const typed = Object.getPrototypeOf(Uint8Array.prototype);
+    const length = Object.getOwnPropertyDescriptor(typed, 'byteLength').get.call(bytes);
+    const backing = Object.getOwnPropertyDescriptor(typed, 'buffer').get.call(bytes);
+    if (types.isSharedArrayBuffer(backing))
+        throw new TypeError('Shared XML bytes are unsupported');
+    if (length > limits.maxBytes)
+        throw new Stop('resource-limit', 'XML byte limit');
+    check();
+    const input = new Uint8Array(length);
+    Uint8Array.prototype.set.call(input, bytes);
+    const uri = sourceUri ?? 'urn:typescript-wsdl-client:observed-direct-xml';
+    if (typeof uri !== 'string')
+        throw new TypeError('XML source URI must be a string');
+    check();
+    return parseOrderedSyntax(input, uri, { ...limits, xml10Only: true, componentResponseEncoding,
+        chargeWork: () => check(), reserveNode: () => { check(); budget.reserveNodes(1); } }).root;
+}
+function assertObservedPayload(root, payload, check) {
+    const pending = [root];
+    while (pending.length) {
+        check();
+        const node = pending.pop();
+        if (node === payload)
+            return;
+        for (let i = node.children.length - 1; i >= 0; i--) {
+            check();
+            const child = node.children[i];
+            if (child.kind === 'element')
+                pending.push(child);
+        }
+    }
+    throw new TypeError('Protocol payload must belong to the observed document');
+}
+/** Observe once through the existing component parser and execution controls.
+ * @remarks Any exact operation-owned mapping can bind parsing to its execution context. Its value/root is not
+ *   assessed here. Source qualification, wrapper scope and selected payload validation remain separate owners.
+ */
+export function observeComponentXml(contract, mapping, bytes, options = {}) {
+    const result = runComponent(contract, mapping, options, (_owned, session) => {
+        const root = parseObservedXml(bytes, session, options.uri ?? 'urn:typescript-wsdl-client:observed-component-xml', options.componentResponseEncoding);
+        directDataOwnership(session.budget).freeze(root);
+        return Object.freeze({ kind: 'observed-component-xml', root, usage: Object.freeze({ ...session.budget.usage() }) });
+    });
+    if (result.kind === 'observed-component-xml')
+        componentObservations.add(result);
+    return result;
+}
+/** Validate a genuine observed subtree through an independently qualified component mapping.
+ * @remarks XML capacities belong to the observation episode. This entry assesses the selected mapping's
+ *   structure and scalar duties; it does not assert cross-contract wrapper, SOAP or runtime authority.
+ * @throws TypeError For copied observations, foreign mappings or a node outside the observed document.
+ */
+export function assessObservedComponentPayload(contract, mapping, observation, payload, options = {}) {
+    if (!componentObservations.has(observation))
+        throw new TypeError('Native component XML observation required');
+    return runComponent(contract, mapping, options, (owned, { budget, check }) => {
+        assertObservedPayload(observation.root, payload, check);
+        const { context } = inspectDirectOperation(contract);
+        if (isRpcMessageRoot(owned.root)) {
+            const control = { budget, check, fail: (kind, rule, node) => { throw new Stop(kind, rule, node?.source); } };
+            const { rpcParts } = inspectComponentValueMapping(owned, contract);
+            const value = rpcParts && owned.direction.kind === 'input' ? readRpcTyped(context, owned.root, rpcParts, payload, control)
+                : readRpcStrings(owned.root, payload, owned.direction.kind === 'output', control);
+            const validated = { kind: rpcParts ? 'rpc-typed-value' : 'rpc-string-value', admitted: false, value, usage: budget.usage() };
+            directDataOwnership(budget).freeze(validated);
+            return { kind: 'component-decoded', admitted: false, payload, validated, mapping: owned, usage: budget.usage() };
+        }
+        const structural = matchDirectProjection(context, owned.root.element, payload, options);
+        if (structural.kind !== 'projection-match')
+            return structural;
+        const validated = assessProjectionScalars(context, structural, options, owned);
+        if (validated.kind !== 'projection-value')
+            return validated;
+        return Object.freeze({ kind: 'component-decoded', admitted: false, payload, validated, mapping: owned,
+            usage: Object.freeze({ ...budget.usage() }) });
+    });
+}
+/** Verify membership without conferring a selected mapping or wrapper validity. */
+export function assertComponentObservedPayload(observation, payload, check) {
+    if (!componentObservations.has(observation))
+        throw new TypeError('Native component XML observation required');
+    assertObservedPayload(observation.root, payload, check);
+}
 /** Bounded observed bytes -> ordered syntax -> existing structural/scalar checks. */
 export function decodeDirectXml(contract, mapping, bytes, options = {}) {
-    return run(contract, mapping, options, (owned, { budget, limits, check }) => {
-        if (!types.isUint8Array(bytes) || types.isProxy(bytes))
-            throw new TypeError('XML requires Uint8Array bytes');
-        // Use native internal-slot access, avoiding subclass/own length, buffer and
-        // iterator getters. Shared backing stores are outside the data-only contract.
-        const typed = Object.getPrototypeOf(Uint8Array.prototype);
-        const length = Object.getOwnPropertyDescriptor(typed, 'byteLength').get.call(bytes);
-        const backing = Object.getOwnPropertyDescriptor(typed, 'buffer').get.call(bytes);
-        if (types.isSharedArrayBuffer(backing))
-            throw new TypeError('Shared XML bytes are unsupported');
-        if (length > limits.maxBytes)
-            throw new Stop('resource-limit', 'XML byte limit');
-        check();
-        const input = new Uint8Array(length);
-        Uint8Array.prototype.set.call(input, bytes);
-        const uri = options.uri ?? 'urn:typescript-wsdl-client:observed-direct-xml';
-        if (typeof uri !== 'string')
-            throw new TypeError('XML source URI must be a string');
-        check();
-        const root = parseOrderedSyntax(input, uri, { ...limits, xml10Only: true,
-            chargeWork: () => check(), reserveNode: () => { check(); budget.reserveNodes(1); } }).root;
+    return run(contract, mapping, options, (owned, session) => {
+        const { budget, check } = session;
+        const root = parseObservedXml(bytes, session, options.uri);
         const selection = options.selectPayload?.(root) ?? { payload: root, mapping: owned };
         const payload = selection.payload;
         const selectedMapping = inspectDirectValueMapping(selection.mapping, contract);
         // Protocol selection may only return an actual node from this parse, never
         // a synthetic tree relabeled with the observed document's provenance.
-        const contains = (node) => {
-            check();
-            return node === payload || node.children.some(child => child.kind === 'element' && contains(child));
-        };
-        if (!contains(root))
-            throw new TypeError('Protocol payload must belong to the observed document');
+        assertObservedPayload(root, payload, check);
         const structural = matchDirectOperation(contract, selectedMapping.direction, payload, options);
         if (structural.kind !== 'structural-match')
             return structural;
@@ -190,3 +373,38 @@ export function decodeDirectXml(contract, mapping, bytes, options = {}) {
             usage: Object.freeze({ ...budget.usage() }) });
     });
 }
+/** Decode observed component-profile bytes through the same parser and native structured/scalar owners.
+ * @remarks Protocol selection may choose only an actual node from this parse and an exact operation-owned mapping.
+ *   It cannot relabel a copied syntax tree, switch operations or acquire runtime/policy enforcement authority.
+ * @returns A native-validated structured value or explicit XML/structure/scalar/unsupported/resource failure.
+ */
+export function decodeComponentXml(contract, mapping, bytes, options = {}) {
+    return runComponent(contract, mapping, options, (owned, session) => {
+        const { budget, check } = session, { context } = inspectDirectOperation(contract);
+        const root = parseObservedXml(bytes, session, options.uri ?? 'urn:typescript-wsdl-client:observed-component-xml', options.componentResponseEncoding);
+        const selection = options.selectPayload?.(root) ?? { payload: root, mapping: owned };
+        const selected = inspectComponentValueMapping(selection.mapping, contract).mapping;
+        assertObservedPayload(root, selection.payload, check);
+        if (isRpcMessageRoot(selected.root)) {
+            const control = { ...session, fail: (kind, rule, node) => { throw new Stop(kind, rule, node?.source); } };
+            const { rpcParts } = inspectComponentValueMapping(selected, contract);
+            const value = rpcParts && selected.direction.kind === 'input' ? readRpcTyped(context, selected.root, rpcParts, selection.payload, control)
+                : readRpcStrings(selected.root, selection.payload, selected.direction.kind === 'output', control);
+            const validated = { kind: rpcParts ? 'rpc-typed-value' : 'rpc-string-value', admitted: false, value, usage: budget.usage() };
+            directDataOwnership(budget).freeze(validated);
+            directDataOwnership(budget).freeze(selection.payload);
+            return { kind: 'component-decoded', admitted: false, payload: selection.payload, validated, mapping: selected, usage: budget.usage() };
+        }
+        const structural = matchDirectProjection(context, selected.root.element, selection.payload, options);
+        if (structural.kind !== 'projection-match')
+            return structural;
+        const validated = assessProjectionScalars(context, structural, options, selected);
+        if (validated.kind !== 'projection-value')
+            return validated;
+        check();
+        directDataOwnership(budget).freeze(selection.payload);
+        check();
+        return Object.freeze({ kind: 'component-decoded', admitted: false, payload: selection.payload,
+            validated, mapping: selected, usage: Object.freeze({ ...budget.usage() }) });
+    });
+}

package/dist/compiler/directExecutionPolicy.d.ts

@@ -7,4 +7,3 @@ export declare function directDataOwnership(budget: SemanticBudget): Readonly<{
 }>;
 export declare function directLimit(budget: SemanticBudget, boundedProfile: number): number;
 export declare function directLoadingLimits(budget: SemanticBudget, overrides?: Partial<LoadingLimits>): Partial<LoadingLimits>;
-//# sourceMappingURL=directExecutionPolicy.d.ts.map

package/dist/compiler/directOperation.d.ts

@@ -4,6 +4,9 @@ import type { ElementNode, Reference } from './canonicalGraph.js';
 import type { SemanticContext } from './semanticContext.js';
 import type { SemanticBudget, SemanticBudgetLimits, ResolverUsage } from './semanticBudget.js';
 import type { DirectSourceQualification } from './checkedSourcePreparation.js';
+import type { ComponentSourceQualification } from './checkedComponentSource.js';
+import type { WsdlPolicyRequirements, BindingPolicyRequirements } from './wsdlPolicyRequirements.js';
+import type { StandardSchemaLibrary } from './standardSchemaComponents.js';
 export interface DirectOperationSelector {
     readonly portType: ExpandedName;
     readonly binding: ExpandedName;
@@ -16,25 +19,57 @@ export interface DirectMessageRoot {
     readonly type: Reference;
     readonly source: SyntaxSource;
 }
+/** Source-owned RPC parameters; these are WSDL parts rather than schema element declarations.
+ * @since 1.1.9
+ */
+export interface RpcMessageRoot {
+    readonly kind: 'rpc-typed-parts-v1';
+    readonly message: ExpandedName;
+    readonly parts: readonly Readonly<{
+        name: string;
+        type: Reference;
+        source: SyntaxSource;
+    }>[];
+    readonly wrapper: ExpandedName;
+    readonly bodyNamespace: string;
+    readonly encoding: 'http://schemas.xmlsoap.org/soap/encoding/';
+    readonly source: SyntaxSource;
+}
+/** Distinguish typed RPC parameters without inventing a document element.
+ * @param root Selected native message.
+ * @returns Whether the message uses the bounded RPC profile.
+ */
+export declare function isRpcMessageRoot(root: DirectMessageRoot | RpcMessageRoot): root is RpcMessageRoot;
 export interface DirectOperationContract {
     readonly selector: DirectOperationSelector;
     readonly contextId: string;
-    readonly basis: 'native-direct-premises-v1';
-    readonly correspondence: 'dated-XSD-2004-direct-v1';
+    readonly basis: 'native-direct-premises-v1' | 'native-component-premises-v1';
+    readonly correspondence: 'dated-XSD-2004-direct-v1' | 'dated-XSD-2004-components-v1';
     readonly binding: Readonly<{
         version: '1.1';
-        style: 'document';
-        use: 'literal';
+        style: 'document' | 'rpc';
+        use: 'literal' | 'encoded';
+        encoding?: string;
         transport: string;
         action: string;
         source: SyntaxSource;
     }>;
-    readonly input: DirectMessageRoot;
-    readonly output: DirectMessageRoot;
+    readonly input: DirectMessageRoot | RpcMessageRoot;
+    readonly output: DirectMessageRoot | RpcMessageRoot;
     readonly faults: readonly Readonly<{
         name: string;
         root: DirectMessageRoot;
     }>[];
+    readonly policy?: BindingPolicyRequirements;
+    readonly addressingActions?: Readonly<{
+        required: false;
+        input?: string;
+        output?: string;
+        faults: readonly Readonly<{
+            name: string;
+            action: string;
+        }>[];
+    }>;
     readonly missingCapabilities: readonly string[];
     readonly admitted: false;
 }
@@ -53,7 +88,8 @@ export interface DirectOperationInspection {
     readonly source: SchemaInput;
     readonly evidence: Extract<DirectSourceQualification, {
         kind: 'qualified-source';
-    }>;
+    }> | ComponentSourceQualification;
+    readonly policyOwner?: WsdlPolicyRequirements;
 }
 /** Object identity authenticates the exact issued roots; context IDs and digests do not. */
 export declare function inspectDirectOperation(contract: DirectOperationContract, expectedContext?: SemanticContext): DirectOperationInspection;
@@ -69,4 +105,32 @@ export declare function selectDirectOperationInRequest(source: string, selector:
     limits?: SemanticBudgetLimits;
     signal?: AbortSignal;
 }>, budget: SemanticBudget): Promise<DirectOperationResult>;
-//# sourceMappingURL=directOperation.d.ts.map
+/** Select through additive native component qualification without granting codec, transport or runtime admission.
+ * @remarks The same WSDL binding/message owner is used by the existing preview. New contracts carry a distinct
+ *   basis and correspondence; preview codecs and source capsules continue to refuse them until independently extended.
+ * @returns Fresh source-bound operation roots or an explicit qualification/selection failure.
+ */
+export declare function selectComponentOperation(source: string, selector: DirectOperationSelector, options: Readonly<{
+    loading: SchemaInputOptions;
+    limits?: SemanticBudgetLimits;
+    signal?: AbortSignal;
+    standardLibraries?: readonly StandardSchemaLibrary[];
+}>): Promise<DirectOperationResult>;
+/** Private composition seam: artifact reading and fresh component selection share the same sticky request. */
+export declare function selectComponentOperationInRequest(source: string, selector: DirectOperationSelector, options: Readonly<{
+    loading: SchemaInputOptions;
+    limits?: SemanticBudgetLimits;
+    signal?: AbortSignal;
+    standardLibraries?: readonly StandardSchemaLibrary[];
+}>, budget: SemanticBudget): Promise<DirectOperationResult>;
+/** Select requested service operations against one fresh native source snapshot and sticky request.
+ * @remarks Native whole-source qualification is reused by identity within this batch only. Every binding/message
+ *   selection still runs through the same owner; no source flags, saved reports or operation-name guesses are consumed.
+ * @returns One result in each requested position, including explicit refusals. No requested operation is omitted.
+ */
+export declare function selectComponentOperations(source: string, selectors: readonly DirectOperationSelector[], options: Readonly<{
+    loading: SchemaInputOptions;
+    limits?: SemanticBudgetLimits;
+    signal?: AbortSignal;
+    standardLibraries?: readonly StandardSchemaLibrary[];
+}>): Promise<readonly DirectOperationResult[]>;