@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

package/dist/compiler/directCodec.js

@@ -4,33 +4,41 @@ 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 { 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';
 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'
+            if (mapping.version !== profile.version || mapping.contextId !== contract.contextId
+                || contract.basis !== profile.basis || contract.correspondence !== profile.correspondence
                 || contract.binding.version !== '1.1' || 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 +80,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 +89,254 @@ 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;
+        // @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) {
+    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,
+        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');
+        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);
+        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 +350,28 @@ 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');
+        const selection = options.selectPayload?.(root) ?? { payload: root, mapping: owned };
+        const selected = inspectComponentValueMapping(selection.mapping, contract).mapping;
+        assertObservedPayload(root, selection.payload, check);
+        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;
@@ -19,8 +22,8 @@ export interface DirectMessageRoot {
 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';
@@ -35,6 +38,16 @@ export interface DirectOperationContract {
         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 +66,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 +83,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[]>;