@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/directCodec.js

@@ -0,0 +1,377 @@
+import { directDataOwnership, directLimit } from './directExecutionPolicy.js';
+/** Internal, buffered, bare-root XML codec. No SOAP envelope or dispatch. */
+import { checkSemanticBudget } from './semanticBudget.js';
+import { DataOwnershipLimitError } from './dataOwnership.js';
+import { types } from 'node:util';
+import { inspectDirectOperation } 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';
+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;
+    source;
+    constructor(kind, rule, source) {
+        super(rule);
+        this.kind = kind;
+        this.rule = rule;
+        this.source = source;
+    }
+}
+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 = 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 !== 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', profile.rule);
+            const direction = mapping.direction;
+            const root = direction.kind === 'fault' ? contract.faults.find(f => {
+                check();
+                return budget.compareText(f.name, direction.name) === 0;
+            })?.root : contract[direction.kind];
+            if (mapping.root !== root)
+                throw new TypeError('Incompatible direct codec root');
+            const configured = options.limits === undefined ? {} : directDataOwnership(budget).snapshot(options.limits, check);
+            if (!configured || typeof configured !== 'object' || Array.isArray(configured))
+                throw new TypeError('Data-only XML limits required');
+            for (const key of Reflect.ownKeys(configured)) {
+                if (typeof key !== 'string' || !['maxBytes', 'maxDepth', 'maxNodes', 'maxText'].includes(key))
+                    throw new TypeError('Unknown XML limit');
+            }
+            const limits = {
+                maxBytes: directLimit(budget, DIRECT_XML_LIMITS.maxBytes), maxDepth: directLimit(budget, DIRECT_XML_LIMITS.maxDepth),
+                maxNodes: directLimit(budget, DIRECT_XML_LIMITS.maxNodes), maxText: directLimit(budget, DIRECT_XML_LIMITS.maxText),
+            };
+            for (const key of ['maxBytes', 'maxDepth', 'maxNodes', 'maxText']) {
+                const value = configured[key];
+                if (value !== undefined) {
+                    if (!Number.isSafeInteger(value) || value < 1)
+                        throw new RangeError('XML limits must be positive safe integers');
+                    limits[key] = value;
+                }
+            }
+            const result = work(mapping, { budget, limits, check });
+            // Native failures remain terminal even though publication has no synthetic work price.
+            check();
+            return Object.freeze({ ...result, usage: Object.freeze({ ...budget.usage() }) });
+        });
+        if (budget.exhausted())
+            return { kind: 'resource-limit', rule: 'request-budget', usage: budget.usage() };
+        return result;
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return { kind: 'resource-limit', rule: 'request-budget', usage: budget.usage() };
+        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,
+                ...(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,
+                usage: Object.freeze({ ...budget.usage() }) });
+        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, 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 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, 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.
+        assertObservedPayload(root, payload, check);
+        const structural = matchDirectOperation(contract, selectedMapping.direction, payload, options);
+        if (structural.kind !== 'structural-match')
+            return structural;
+        const validated = assessDirectScalars(contract, structural, options);
+        if (validated.kind !== 'direct-value')
+            return validated;
+        check();
+        directDataOwnership(budget).freeze(payload);
+        check();
+        return Object.freeze({ kind: 'direct-decoded', admitted: false, payload, validated,
+            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

@@ -0,0 +1,9 @@
+import type { SemanticBudget } from './semanticBudget.js';
+import type { LoadingLimits } from '../loader/schemaResources.js';
+export declare const DIRECT_REPRESENTATION_MAX: number;
+export declare function directDataOwnership(budget: SemanticBudget): Readonly<{
+    snapshot: <T>(value: T, check?: () => void) => T;
+    freeze: <T>(value: T) => Readonly<T>;
+}>;
+export declare function directLimit(budget: SemanticBudget, boundedProfile: number): number;
+export declare function directLoadingLimits(budget: SemanticBudget, overrides?: Partial<LoadingLimits>): Partial<LoadingLimits>;

package/dist/compiler/directExecutionPolicy.js

@@ -0,0 +1,17 @@
+/** Application-selected resource policy; numeric maxima below are representation ceilings, not quotas. */
+import { createDataOwnership, dataOwnership } from './dataOwnership.js';
+import { isApplicationUnmetered } from './semanticBudget.js';
+import { DEFAULT_LOADING_LIMITS } from '../loader/schemaResources.js';
+const unrestrictedData = createDataOwnership(() => { });
+export const DIRECT_REPRESENTATION_MAX = Number.MAX_SAFE_INTEGER;
+export function directDataOwnership(budget) {
+    return isApplicationUnmetered(budget) ? unrestrictedData : dataOwnership;
+}
+export function directLimit(budget, boundedProfile) {
+    return isApplicationUnmetered(budget) ? DIRECT_REPRESENTATION_MAX : boundedProfile;
+}
+export function directLoadingLimits(budget, overrides) {
+    if (!isApplicationUnmetered(budget))
+        return overrides ?? {};
+    return { ...Object.fromEntries(Object.keys(DEFAULT_LOADING_LIMITS).map(key => [key, key === 'resourceMs' || key === 'totalIoMs' ? 0 : DIRECT_REPRESENTATION_MAX])), ...overrides };
+}

package/dist/compiler/directOperation.d.ts

@@ -0,0 +1,114 @@
+import type { SchemaInput, SchemaInputOptions } from '../loader/schemaInput.js';
+import type { ExpandedName, SyntaxSource } from '../loader/orderedSyntax.js';
+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;
+    readonly operation: string;
+}
+export interface DirectMessageRoot {
+    readonly message: ExpandedName;
+    readonly part: string;
+    readonly element: ElementNode;
+    readonly type: Reference;
+    readonly source: SyntaxSource;
+}
+export interface DirectOperationContract {
+    readonly selector: DirectOperationSelector;
+    readonly contextId: string;
+    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';
+        transport: string;
+        action: string;
+        source: SyntaxSource;
+    }>;
+    readonly input: DirectMessageRoot;
+    readonly output: DirectMessageRoot;
+    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;
+}
+export type DirectOperationResult = Readonly<{
+    kind: 'selected';
+    contract: DirectOperationContract;
+    usage: ResolverUsage;
+}> | Readonly<{
+    kind: 'invalid-schema' | 'inconclusive' | 'unsupported' | 'selection-refused' | 'loading-refused' | 'resource-limit' | 'cancelled';
+    rule: string;
+    usage: ResolverUsage;
+}>;
+export interface DirectOperationInspection {
+    readonly contract: DirectOperationContract;
+    readonly context: SemanticContext;
+    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;
+/** One load, whole-source qualification, explicit selection and publication on one sticky budget. */
+export declare function selectDirectOperation(source: string, selector: DirectOperationSelector, options: Readonly<{
+    loading: SchemaInputOptions;
+    limits?: SemanticBudgetLimits;
+    signal?: AbortSignal;
+}>): Promise<DirectOperationResult>;
+/** Private-module composition seam: portable reading and selection share one request. */
+export declare function selectDirectOperationInRequest(source: string, selector: DirectOperationSelector, options: Readonly<{
+    loading: SchemaInputOptions;
+    limits?: SemanticBudgetLimits;
+    signal?: AbortSignal;
+}>, budget: SemanticBudget): Promise<DirectOperationResult>;
+/** 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[]>;