@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/re01CandidateCorrespondence.js

@@ -20,6 +20,43 @@ class CorrespondenceAbort extends Error {
         this.result = result;
     }
 }
+/** Read effective original properties through the existing native source owners; cached data grants no validity. */
+function mapActualComplexProperties(actual, id) {
+    const b = actual.budget, charge = b.chargeWork;
+    let cache = actualMappings.get(actual);
+    if (!cache) {
+        charge(2);
+        cache = new Map();
+        actualMappings.set(actual, cache);
+    }
+    const cached = cache.get(id);
+    if (cached)
+        return cached;
+    const found = actual.lookup(id);
+    if (found.kind !== 'found' || found.node.kind !== 'complexType')
+        throw new CorrespondenceAbort(Object.freeze({ kind: 'invalid-evidence',
+            rule: 'original-property-correspondence', component: id, message: 'Expected an original complex type' }));
+    const original = found.node;
+    const content = deriveActualComplexContent(actual, id), attrs = assessSourceAttributeUses(actual, id);
+    if (content.kind !== 'checked')
+        throw new CorrespondenceAbort(content.kind === 'resource-limit' ? content
+            : { ...content, kind: content.kind === 'invalid-input' ? 'invalid-evidence' : 'unresolved' });
+    if (attrs.kind !== 'checked')
+        throw new CorrespondenceAbort(attrs);
+    charge(20 + attrs.value.uses.length);
+    const properties = {
+        type: id, derivation: { method: original.derivation?.kind ?? 'restriction', base: original.derivation?.base ?? ANY_TYPE },
+        targetNamespace: original.context.effectiveNamespace,
+        abstract: original.abstract, final: declarationMethods(actual, original, 'final'),
+        block: declarationMethods(actual, original, 'block'), content: content.view.content,
+        attributeUses: attrs.value.uses.map(use => use.id), wildcard: attrs.value.wildcard, provenance: { kind: 'actual-mapped', original: id },
+    };
+    charge(9);
+    const result = Object.freeze({ properties: b.freeze(b.snapshot(properties)), context: actual,
+        view: content.view, synthetic: content.view.synthetic, scalarObligations: attrs.scalarObligations, typeDependencies: attrs.typeDependencies });
+    cache.set(id, result);
+    return result;
+}
 export function assertCandidateCorrespondence(context, receipt) {
     assertSemanticContext(context);
     if (issued.get(receipt) !== context)
@@ -311,47 +348,12 @@ export function checkCandidateCorrespondence(actual, parent, candidate, target,
                 }
                 return { properties: prior, context: parent, synthetic: [], scalarObligations: [], typeDependencies: [] };
             }
-            let cache = actualMappings.get(actual);
-            if (!cache) {
-                charge(2);
-                cache = new Map();
-                actualMappings.set(actual, cache);
-            }
-            const cached = cache.get(id);
-            if (cached) {
-                typeDependencies.add(cached.typeDependencies);
-                for (const obligation of cached.scalarObligations) {
-                    charge(3);
-                    scalarObligations.push({ contextId: obligation.contextId ?? actual.contextId, obligation });
-                }
-                return cached;
-            }
-            const original = node(actual, id);
-            if (original.kind !== 'complexType')
-                return fail('original-property-correspondence', id, 'Expected an original complex type', 'invalid-evidence');
-            const content = deriveActualComplexContent(actual, id), attrs = assessSourceAttributeUses(actual, id);
-            if (content.kind !== 'checked')
-                throw new CorrespondenceAbort(content.kind === 'resource-limit' ? content
-                    : { ...content, kind: content.kind === 'invalid-input' ? 'invalid-evidence' : 'unresolved' });
-            if (attrs.kind !== 'checked')
-                throw new CorrespondenceAbort(attrs);
-            typeDependencies.add(attrs.typeDependencies);
-            for (const obligation of attrs.scalarObligations) {
+            const result = mapActualComplexProperties(actual, id);
+            typeDependencies.add(result.typeDependencies);
+            for (const obligation of result.scalarObligations) {
                 charge(3);
                 scalarObligations.push({ contextId: obligation.contextId ?? actual.contextId, obligation });
             }
-            charge(20 + attrs.value.uses.length);
-            const properties = {
-                type: id, derivation: { method: original.derivation?.kind ?? 'restriction', base: original.derivation?.base ?? ANY_TYPE },
-                targetNamespace: original.context.effectiveNamespace,
-                abstract: original.abstract, final: declarationMethods(actual, original, 'final'),
-                block: declarationMethods(actual, original, 'block'), content: content.view.content,
-                attributeUses: attrs.value.uses.map(use => use.id), wildcard: attrs.value.wildcard, provenance: { kind: 'actual-mapped', original: id },
-            };
-            charge(9);
-            const result = Object.freeze({ properties: b.freeze(b.snapshot(properties)), context: actual,
-                view: content.view, synthetic: content.view.synthetic, scalarObligations: attrs.scalarObligations, typeDependencies: attrs.typeDependencies });
-            cache.set(id, result);
             return result;
         };
         const typeNamespace = (context, id, properties) => {
@@ -570,3 +572,130 @@ export function checkCandidateCorrespondence(actual, parent, candidate, target,
         }
     });
 }
+const additiveProperties = new WeakMap();
+/** Authenticate simple-content property correspondence independently of construction and dated interpretation. */
+export function assertAdditiveSimpleProperties(actual, context, receipt) {
+    assertSemanticContext(actual);
+    assertSemanticContext(context);
+    const issued = additiveProperties.get(receipt);
+    if (!issued || issued.actual !== actual || issued.context !== context)
+        throw new TypeError('Fresh matching additive property correspondence required');
+}
+/** Compare fresh simple-content representatives with native effective source properties, preserving every original binding.
+ * @remarks Identity/name and derivation are deliberately distinct for the fresh restriction representative.
+ *   Its other effective complex properties must match the original target. The middle carries the same attributes
+ *   and extends the exact designated simple ancestor. Local legality, aggregate closure and dated interpretation
+ *   remain separate obligations; producer provenance labels grant none of them.
+ * @returns Authenticated native property correspondence or an explicit mismatch/unavailable/resource result.
+ * @throws TypeError For unauthenticated or unrelated contexts.
+ */
+export function checkAdditiveSimpleProperties(actual, candidate, target, intermediate, representative) {
+    assertSemanticContext(actual);
+    assertSemanticContext(candidate);
+    if (!contextsShareRequest(actual, candidate) || !isSemanticCandidateOf(actual, candidate))
+        throw new TypeError('Expected a direct child of this actual request');
+    const b = actual.budget, charge = b.chargeWork;
+    return b.guard(() => {
+        const fail = (rule, message, kind = 'candidate-rejected') => {
+            charge(32 + rule.length + message.length + target.length);
+            throw new CorrespondenceAbort(Object.freeze({ kind, rule, component: target, contextId: candidate.contextId, message }));
+        };
+        try {
+            if (actual.kind !== 'actual' || actual.membership !== 'complete-actual-plus-additions' || candidate.membership !== 'complete-actual-plus-additions')
+                return fail('additive-source-context', 'Complete actual source membership is required', 'unresolved');
+            if (intermediate === representative || actual.lookup(intermediate).kind !== 'missing' || actual.lookup(representative).kind !== 'missing'
+                || candidate.members.length !== actual.members.length + 2)
+                return fail('additive-fresh-types', 'Exactly two fresh type components are required');
+            for (const id of actual.members) {
+                charge(16 + id.length);
+                const before = actual.lookup(id), after = candidate.lookup(id);
+                if (before.kind !== 'found' || after.kind !== 'found' || before.node !== after.node
+                    || actual.rawTypeProperties(id) !== candidate.rawTypeProperties(id)
+                    || actual.rawSimpleTypeProperties(id) !== candidate.rawSimpleTypeProperties(id)
+                    || actual.rawElementProperties(id) !== candidate.rawElementProperties(id)
+                    || actual.rawAttributeProperties(id) !== candidate.rawAttributeProperties(id)
+                    || actual.rawAttributeGroupProperties(id) !== candidate.rawAttributeGroupProperties(id)
+                    || actual.rawParticleWildcardProperties(id) !== candidate.rawParticleWildcardProperties(id)
+                    || actual.owner(id) !== candidate.owner(id))
+                    return fail('additive-original-preservation', 'An original component or scope binding changed');
+            }
+            const e = candidate.lookup(intermediate), c = candidate.lookup(representative);
+            if (e.kind !== 'found' || c.kind !== 'found' || e.node.kind !== 'complexType' || c.node.kind !== 'complexType')
+                return fail('additive-fresh-types', 'Fresh extension and restriction complex types are required');
+            const original = mapActualComplexProperties(actual, target), middle = candidate.rawTypeProperties(intermediate), end = candidate.rawTypeProperties(representative);
+            if (!middle || !end)
+                return fail('additive-raw-properties', 'Complete fresh complex properties are required', 'unresolved');
+            if (original.properties.content.kind !== 'simple' || middle.content.kind !== 'simple' || end.content.kind !== 'simple')
+                return fail('additive-simple-content-family', 'This property route supports only simple content', 'unresolved');
+            const designated = re01Ancestor(actual, target);
+            if (designated.kind !== 'checked')
+                throw new CorrespondenceAbort(designated);
+            const typeDependencies = collectSemanticTypeDependencies(candidate);
+            typeDependencies.add(original.typeDependencies);
+            typeDependencies.add(designated.typeDependencies);
+            const key = (context, reference) => {
+                const resolved = resolveSemanticType(context, reference);
+                if (!('identity' in resolved))
+                    return fail('additive-type-reference', 'A property type is unavailable', 'unresolved');
+                typeDependencies.add([{ contextId: context.contextId, type: resolved.identity }]);
+                return semanticTypeKey(context, resolved.identity);
+            };
+            const sameSet = (left, right) => {
+                charge(4);
+                const a = new Set(), z = new Set();
+                for (const value of left) {
+                    charge(2 + value.length);
+                    a.add(value);
+                }
+                for (const value of right) {
+                    charge(2 + value.length);
+                    z.add(value);
+                }
+                if (a.size !== z.size)
+                    return false;
+                for (const value of a) {
+                    charge(2 + value.length);
+                    if (!z.has(value))
+                        return false;
+                }
+                return true;
+            };
+            const sameWildcard = (left, right) => {
+                charge(4);
+                if (!left.wildcard || !right.wildcard)
+                    return left.wildcard === right.wildcard;
+                return left.wildcard.processContents === right.wildcard.processContents
+                    && namespaceSetSubset(left.wildcard.namespace, right.wildcard.namespace, charge)
+                    && namespaceSetSubset(right.wildcard.namespace, left.wildcard.namespace, charge);
+            };
+            if (middle.derivation.method !== 'extension' || end.derivation.method !== 'restriction'
+                || key(candidate, middle.derivation.base) !== key(actual, designated.ancestor)
+                || key(candidate, end.derivation.base) !== key(candidate, { kind: 'local', target: intermediate }))
+                return fail('additive-derivation-chain', 'The representatives do not have the required extension/restriction chain');
+            if (key(candidate, middle.content.type) !== key(actual, designated.ancestor)
+                || key(candidate, end.content.type) !== key(actual, original.properties.content.type))
+                return fail('additive-content-correspondence', 'Representative scalar content differs from its native source property');
+            const prior = original.properties;
+            if (end.targetNamespace !== prior.targetNamespace || end.abstract !== prior.abstract
+                || !sameSet(end.final, prior.final) || !sameSet(end.block, prior.block)
+                || !sameSet(end.attributeUses, prior.attributeUses) || !sameWildcard(end, prior))
+                return fail('additive-target-properties', 'The restriction representative changed an effective target property');
+            if (middle.targetNamespace !== prior.targetNamespace || middle.abstract || middle.final.length || middle.block.length
+                || !sameSet(middle.attributeUses, prior.attributeUses) || !sameWildcard(middle, prior))
+                return fail('additive-middle-properties', 'The extension representative changed the selected middle properties');
+            charge(128);
+            const result = Object.freeze({ kind: 'checked-additive-simple-properties', actualContextId: actual.contextId,
+                contextId: candidate.contextId, target, intermediate, representative, scalarObligations: original.scalarObligations,
+                typeDependencies: typeDependencies.snapshot(), datedInterpretation: 'unassessed' });
+            additiveProperties.set(result, Object.freeze({ actual, context: candidate }));
+            return result;
+        }
+        catch (error) {
+            if (error instanceof CorrespondenceAbort)
+                return error.result;
+            if (error instanceof RelationProblem)
+                return Object.freeze({ kind: 'unresolved', rule: error.result.rule, component: error.result.component, message: error.message });
+            throw error;
+        }
+    });
+}

package/dist/compiler/re01TypeProperties.d.ts

@@ -68,4 +68,3 @@ export type RawComplexTypeProperties = Readonly<{
 /** Runtime data-shape boundary, shared by preparation and property consumers. */
 export declare function assertRawComplexTypeShape(value: unknown, budget: SemanticBudget): asserts value is RawComplexTypeProperties;
 export {};
-//# sourceMappingURL=re01TypeProperties.d.ts.map

package/dist/compiler/re01TypePropertyValidation.d.ts

@@ -20,4 +20,3 @@ export type RawTypeValidation = Readonly<{
 }> | ResourceLimitFailure;
 /** The context has already copied data and rejected accessors. No caller labels authenticate actual mapping. */
 export declare function validateRawComplexTypeProperties(context: SemanticContext, typeId: NodeId, correspondence?: CorrespondenceReceipt): RawTypeValidation;
-//# sourceMappingURL=re01TypePropertyValidation.d.ts.map

package/dist/compiler/resolveCanonicalGraph.d.ts

@@ -1,5 +1,6 @@
 import type { CanonicalGraph, GraphNode, NodeId, Reference } from "./canonicalGraph.js";
 import type { SyntaxSource } from "../loader/orderedSyntax.js";
+import type { StandardSchemaLibrary, StandardSchemaElementDeclaration } from './standardSchemaComponents.js';
 export declare class SemanticError extends Error {
     readonly category: "invalid-schema" | "unsupported-capability" | "incompatible-artifact" | "resource-limit";
     readonly component?: NodeId | undefined;
@@ -11,6 +12,7 @@ export type SemanticLimits = {
     maxNodes?: number;
     maxSteps?: number;
     requestBudget?: import("./semanticBudget.js").SemanticBudget;
+    standardLibraries?: readonly StandardSchemaLibrary[];
 };
 export declare function semanticBudget(limits?: SemanticLimits): {
     maxNodes: number;
@@ -32,7 +34,8 @@ export type ResolvedGraph = Readonly<{
         steps: number;
     }>;
 }>;
+/** Native acquired dependencies only; copied graph reports cannot recreate this association. */
+export declare function standardSchemaLibrariesForResolved(resolved: ResolvedGraph): readonly StandardSchemaLibrary[] | undefined;
 /** Resolve against a node index, never against generated names or an asserted stored target. */
-export declare function referenceTarget(reference: Reference, nodes: ReadonlyMap<NodeId, GraphNode>, owner: GraphNode): NodeId | undefined;
+export declare function referenceTarget(reference: Reference, nodes: ReadonlyMap<NodeId, GraphNode>, owner: GraphNode, standards?: ReadonlyMap<NodeId, StandardSchemaElementDeclaration>): NodeId | undefined;
 export declare function resolveCanonicalGraph(graph: CanonicalGraph, limits?: SemanticLimits): ResolvedGraph;
-//# sourceMappingURL=resolveCanonicalGraph.d.ts.map

package/dist/compiler/resolveCanonicalGraph.js

@@ -3,6 +3,8 @@ import { deepFreeze, DEFAULT_GRAPH_NODES, globalId, isBuiltinType } from "./cano
 import { positiveLimit } from "./catalogErrors.js";
 import { referenceSlots, containedNodes } from "./graphTraversal.js";
 import { syntaxAttribute, XSD_NAMESPACE } from "../loader/orderedSyntax.js";
+import { normalizeWhitespace } from '../util/xmlWhitespace.js';
+import { standardSchemaElement, inspectStandardSchemaElement } from './standardSchemaComponents.js';
 export class SemanticError extends Error {
     category;
     component;
@@ -17,6 +19,12 @@ export class SemanticError extends Error {
         this.name = "SemanticError";
     }
 }
+/** Internal missing-symbol detail; source resolution must distinguish absent import resources from disproved declarations. */
+class MissingReferenceError extends SemanticError {
+    constructor(reference, owner, id) {
+        super('invalid-schema', `Missing reference target ${id}`, owner.id, reference.kind === 'symbol' ? reference.lexical.context.source : owner.context.source);
+    }
+}
 export function semanticBudget(limits = {}) {
     const maxNodes = positiveLimit(limits.maxNodes, DEFAULT_GRAPH_NODES, "maxNodes");
     const maxSteps = positiveLimit(limits.maxSteps, 1_000_000, "maxSteps");
@@ -47,8 +55,13 @@ export function countSemanticData(value, budget, node) {
             }
     }
 }
+const resolvedStandards = new WeakMap();
+/** Native acquired dependencies only; copied graph reports cannot recreate this association. */
+export function standardSchemaLibrariesForResolved(resolved) {
+    return resolvedStandards.get(resolved);
+}
 /** Resolve against a node index, never against generated names or an asserted stored target. */
-export function referenceTarget(reference, nodes, owner) {
+export function referenceTarget(reference, nodes, owner, standards) {
     if (reference.kind === "builtin") {
         if (reference.name.namespace !== XSD_NAMESPACE || !isBuiltinType(reference.name.local))
             throw new SemanticError("invalid-schema", "Unknown builtin type", owner.id, owner.context.source);
@@ -56,8 +69,16 @@ export function referenceTarget(reference, nodes, owner) {
     }
     const id = reference.kind === "symbol" ? globalId(reference.role, reference.name) : reference.target;
     const target = nodes.get(id);
-    if (!target)
-        throw new SemanticError("invalid-schema", `Missing reference target ${id}`, owner.id, reference.kind === "symbol" ? reference.lexical.context.source : owner.context.source);
+    if (!target) {
+        const supplied = standards?.get(id);
+        if (!supplied)
+            throw new MissingReferenceError(reference, owner, id);
+        inspectStandardSchemaElement(supplied);
+        if (reference.kind !== 'symbol' || reference.role !== 'element' || supplied.id !== id
+            || reference.target !== undefined && reference.target !== id)
+            throw new SemanticError('invalid-schema', 'Standard declaration reference role/identity mismatch', owner.id, owner.context.source);
+        return id;
+    }
     if (reference.kind === "symbol" && (target.identity.kind !== "global" || target.identity.role !== reference.role || (reference.target !== undefined && reference.target !== id))) {
         throw new SemanticError("invalid-schema", `Reference role/identity mismatch ${id}`, owner.id, reference.lexical.context.source);
     }
@@ -78,9 +99,23 @@ export function resolveCanonicalGraph(graph, limits = {}) {
     const nodes = new Map(graph.nodes.map(n => [n.id, n]));
     if (nodes.size !== graph.nodes.length)
         throw new SemanticError("invalid-schema", "Duplicate graph identities");
+    const standards = new Map(), selectedLibraries = [];
+    for (const library of limits.standardLibraries ?? []) {
+        budget.step();
+        const declaration = standardSchemaElement(library, { namespace: XSD_NAMESPACE, local: 'schema' });
+        if (!declaration)
+            throw new SemanticError('unsupported-capability', 'Standard library supplies no implemented schema element');
+        if (standards.has(declaration.id))
+            throw new SemanticError('unsupported-capability', 'Duplicate standard library selection');
+        if (nodes.has(declaration.id))
+            throw new SemanticError('unsupported-capability', 'Acquired standard declaration conflicts with explicit schema source; select one source authority');
+        standards.set(declaration.id, declaration);
+        selectedLibraries.push(library);
+    }
     // Imports authorize foreign namespaces in the declaring interpretation only.
     // Including/importing documents do not lend their import permissions to a reference.
     const imports = new Map(), unknownImports = new Set();
+    const unlocatedImports = new Map();
     const sourceKey = (source) => JSON.stringify([source.uri, source.digest, source.path]);
     const importSyntax = new Map(graph.schemaRetained.filter(r => r.syntax.name.namespace === XSD_NAMESPACE && r.syntax.name.local === "import")
         .map(r => [sourceKey(r.syntax.source), r.syntax]));
@@ -89,7 +124,7 @@ export function resolveCanonicalGraph(graph, limits = {}) {
         if (edge.kind !== "import")
             continue;
         const syntax = importSyntax.get(sourceKey(edge.source));
-        const ns = syntax ? syntaxAttribute(syntax, "namespace") ?? "" : edge.to ? interpretation(edge.to).namespace : undefined;
+        const ns = syntax ? normalizeWhitespace(syntaxAttribute(syntax, "namespace") ?? "", 'collapse') : edge.to ? interpretation(edge.to).namespace : undefined;
         if (ns === undefined) {
             unknownImports.add(edge.from);
             continue;
@@ -99,13 +134,42 @@ export function resolveCanonicalGraph(graph, limits = {}) {
         const values = imports.get(edge.from) ?? new Set();
         values.add(ns);
         imports.set(edge.from, values);
+        if (!edge.to && syntax && syntaxAttribute(syntax, 'schemaLocation') === undefined) {
+            const pending = unlocatedImports.get(edge.from) ?? new Set();
+            pending.add(ns);
+            unlocatedImports.set(edge.from, pending);
+        }
     }
     const links = [];
+    let unresolvedImport;
     for (const node of graph.nodes) {
         budget.step(node);
         for (const slot of referenceSlots(node)) {
             budget.step(node);
-            const ref = slot.reference, target = referenceTarget(ref, nodes, node);
+            const ref = slot.reference;
+            let target;
+            let unavailable;
+            try {
+                target = referenceTarget(ref, nodes, node, standards);
+            }
+            catch (error) {
+                if (error instanceof MissingReferenceError && ref.kind === 'symbol' && node.kind !== 'wsdl') {
+                    for (const origin of graph.origins[node.id] ?? []) {
+                        budget.step(node);
+                        if (ref.name.namespace !== origin.context.effectiveNamespace && unlocatedImports.get(origin.interpretation)?.has(ref.name.namespace)) {
+                            unavailable = new SemanticError('unsupported-capability', `Missing declaration in namespace ${ref.name.namespace}; supply the locationless import dependency explicitly`, node.id, ref.lexical.context.source);
+                            break;
+                        }
+                    }
+                }
+                if (!unavailable)
+                    throw error;
+            }
+            // @why P1-D01: missing dependency evidence must not mask independent actual reference failures.
+            if (unavailable) {
+                unresolvedImport ??= unavailable;
+                continue;
+            }
             if (ref.kind === "symbol" && node.kind !== "wsdl") {
                 for (const origin of graph.origins[node.id] ?? []) {
                     budget.step(node);
@@ -121,6 +185,8 @@ export function resolveCanonicalGraph(graph, limits = {}) {
             links.push({ owner: node.id, path: slot.path, reference: ref, ...(target ? { target } : {}) });
         }
     }
+    if (unresolvedImport)
+        throw unresolvedImport;
     // Only expansion/base edges enter this DAG. Element -> type and particle -> element
     // are deliberately excluded: crossing an element admits complete recursive values.
     const forbidden = (n) => {
@@ -130,7 +196,9 @@ export function resolveCanonicalGraph(graph, limits = {}) {
             const expansion = n.kind === "simpleType" || n.kind === "complexType" || n.kind === "attributeGroupUse" ||
                 (n.kind === "particle" && n.term.kind === "group") || (n.kind === "element" && slot.path === "substitutionGroup");
             if (expansion) {
-                const target = referenceTarget(slot.reference, nodes, n);
+                const target = referenceTarget(slot.reference, nodes, n, standards);
+                if (target && standards.has(target))
+                    throw new SemanticError('unsupported-capability', 'Substitution affiliation to an acquired standard element is not implemented', n.id, n.context.source);
                 if (target)
                     result.push(target);
             }
@@ -166,5 +234,7 @@ export function resolveCanonicalGraph(graph, limits = {}) {
         }
     }
     const result = { graph, links, metrics: { steps: budget.steps } };
-    return limits.requestBudget ? limits.requestBudget.freeze(result) : deepFreeze(result);
+    const frozen = limits.requestBudget ? limits.requestBudget.freeze(result) : deepFreeze(result);
+    resolvedStandards.set(frozen, Object.freeze(selectedLibraries));
+    return frozen;
 }

package/dist/compiler/rpcStringValues.d.ts

@@ -0,0 +1,30 @@
+import type { SyntaxElement } from '../loader/orderedSyntax.js';
+import type { RpcMessageRoot } from './directOperation.js';
+import type { SemanticBudget } from './semanticBudget.js';
+type Fail = (kind: 'value-invalid' | 'unsupported' | 'mismatch', rule: string, node?: SyntaxElement) => never;
+type Control = {
+    budget: SemanticBudget;
+    check(): void;
+    fail: Fail;
+};
+/** Build canonical inline string parameters in source declaration order.
+ * @param root Source-owned typed parameters.
+ * @param value Data-only application object.
+ * @param control Shared invocation ownership and work budget.
+ * @returns A generated RPC wrapper and preserved string values.
+ * @throws Through the supplied failure callback for invalid application values.
+ */
+export declare function expandRpcStrings(root: RpcMessageRoot, value: unknown, control: Control): {
+    payload: SyntaxElement;
+    value: Readonly<Record<string, string>>;
+};
+/** Decode only the selected inline/local-reference string profile within one retained Body.
+ * @param root Source-owned typed parameters and body namespace.
+ * @param payload Observed RPC wrapper or observed SOAP Body.
+ * @param output Whether SOAP response local names are insignificant.
+ * @param control Shared native invocation budget and explicit failure callback.
+ * @returns Values keyed by the original WSDL part names.
+ * @throws Through the failure callback for malformed, ambiguous or unsupported encoded values.
+ */
+export declare function readRpcStrings(root: RpcMessageRoot, payload: SyntaxElement, output: boolean, control: Control): Readonly<Record<string, string>>;
+export {};

package/dist/compiler/rpcStringValues.js

@@ -0,0 +1,196 @@
+/** Bounded SOAP 1.1 RPC string serialization, without a second schema engine.
+ * @since 1.1.9
+ * @see https://www.w3.org/TR/2000/NOTE-SOAP-20000508/ Sections 5 and 7.
+ */
+import { isXmlNCName, resolveLexicalQName, syntaxAttribute, syntaxElements, XSD_NAMESPACE, XML_NAMESPACE } from '../loader/orderedSyntax.js';
+import { isXmlCharacters } from './directStructurePlan.js';
+import { directDataOwnership } from './directExecutionPolicy.js';
+const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
+const ENC = 'http://schemas.xmlsoap.org/soap/encoding/';
+const XSI = 'http://www.w3.org/2001/XMLSchema-instance';
+/** Build canonical inline string parameters in source declaration order.
+ * @param root Source-owned typed parameters.
+ * @param value Data-only application object.
+ * @param control Shared invocation ownership and work budget.
+ * @returns A generated RPC wrapper and preserved string values.
+ * @throws Through the supplied failure callback for invalid application values.
+ */
+export function expandRpcStrings(root, value, control) {
+    const { budget, check, fail } = control;
+    let owned;
+    try {
+        owned = directDataOwnership(budget).snapshot(value, check);
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return fail('value-invalid', 'rpc-data-object-required');
+        throw error;
+    }
+    if (!owned || typeof owned !== 'object' || Array.isArray(owned))
+        return fail('value-invalid', 'rpc-data-object-required');
+    const object = owned;
+    const keys = Object.keys(object), names = new Set(root.parts.map(part => { check(); return part.name; }));
+    budget.chargeWork(64 + keys.length * 32 + names.size * 32);
+    if (keys.length !== root.parts.length || keys.some(key => { check(); return !names.has(key); }))
+        return fail('value-invalid', 'rpc-required-string-parts');
+    const namespaces = { xml: XML_NAMESPACE, '': '', rpc: root.bodyNamespace, xsi: XSI, xsd: XSD_NAMESPACE, enc: ENC, soap: SOAP };
+    const attribute = (namespace, local, value) => ({ name: { namespace, local }, lexicalName: local, value });
+    const result = Object.create(null);
+    const children = root.parts.map(part => {
+        check();
+        const text = object[part.name];
+        if (typeof text !== 'string')
+            return fail('value-invalid', 'rpc-required-string-parts');
+        budget.chargeWork(64 + text.length * 8);
+        if (!isXmlCharacters(text))
+            return fail('value-invalid', 'rpc-string-xml-characters');
+        result[part.name] = text;
+        return { kind: 'element', name: { namespace: '', local: part.name }, lexicalName: part.name, namespaces, baseUri: root.source.uri,
+            attributes: [attribute(XSI, 'type', 'xsd:string')], children: [{ kind: 'text', value: text, source: root.source }], source: root.source };
+    });
+    return { payload: { kind: 'element', name: root.wrapper, lexicalName: 'rpc:' + root.wrapper.local, namespaces,
+            baseUri: root.source.uri, attributes: [attribute(SOAP, 'encodingStyle', ENC)], children, source: root.source }, value: result };
+}
+/** Decode only the selected inline/local-reference string profile within one retained Body.
+ * @param root Source-owned typed parameters and body namespace.
+ * @param payload Observed RPC wrapper or observed SOAP Body.
+ * @param output Whether SOAP response local names are insignificant.
+ * @param control Shared native invocation budget and explicit failure callback.
+ * @returns Values keyed by the original WSDL part names.
+ * @throws Through the failure callback for malformed, ambiguous or unsupported encoded values.
+ */
+export function readRpcStrings(root, payload, output, control) {
+    const { budget, check, fail } = control;
+    const elements = (node) => {
+        check();
+        budget.chargeWork(32 + node.children.length * 8 + node.attributes.length * 16);
+        if (node.children.some(c => c.kind === 'text' && /[^\t\r\n ]/.test(c.value)))
+            return fail('mismatch', 'rpc-unexpected-text', node);
+        return syntaxElements(node);
+    };
+    const encoding = (node) => {
+        const declared = syntaxAttribute(node, 'encodingStyle', SOAP);
+        if (declared !== undefined && declared.trim() !== ENC)
+            return fail('unsupported', 'rpc-encoding-style', node);
+    };
+    const rootMarker = (node) => {
+        const marker = syntaxAttribute(node, 'root', ENC);
+        if (marker !== undefined && marker !== '0' && marker !== '1')
+            return fail('mismatch', 'rpc-root-marker', node);
+        return marker;
+    };
+    const attrs = (node, wrapper = false) => {
+        encoding(node);
+        rootMarker(node);
+        for (const attr of node.attributes) {
+            check();
+            if (attr.name.namespace === SOAP && attr.name.local === 'encodingStyle' || attr.name.namespace === ENC && attr.name.local === 'root'
+                || attr.name.namespace === '' && attr.name.local === 'id' || !wrapper && (attr.name.namespace === '' && attr.name.local === 'href'
+                || attr.name.namespace === XSI && attr.name.local === 'type'))
+                continue;
+            return fail('unsupported', 'rpc-encoded-attribute', node);
+        }
+    };
+    const body = payload.name.namespace === SOAP && payload.name.local === 'Body' ? payload : undefined;
+    if (body) {
+        encoding(body);
+        if (body.attributes.some(a => a.name.namespace !== SOAP || a.name.local !== 'encodingStyle'))
+            return fail('unsupported', 'rpc-body-attribute', body);
+    }
+    const top = body ? elements(body) : [payload];
+    const ids = new Map();
+    const pending = [...top];
+    while (pending.length) {
+        check();
+        const node = pending.pop();
+        budget.chargeWork(32 + node.children.length * 8);
+        const id = syntaxAttribute(node, 'id');
+        if (id !== undefined) {
+            if (!isXmlNCName(id) || ids.has(id))
+                return fail('mismatch', 'rpc-duplicate-or-invalid-id', node);
+            ids.set(id, node);
+        }
+        pending.push(...syntaxElements(node));
+    }
+    const wrappers = top.filter(node => {
+        check();
+        return node.name.namespace === root.bodyNamespace && rootMarker(node) !== '0'
+            && syntaxAttribute(node, 'href') === undefined && syntaxAttribute(node, 'type', XSI) === undefined
+            && (!output ? node.name.local === root.wrapper.local : true);
+    });
+    if (wrappers.length !== 1)
+        return fail('mismatch', 'rpc-unambiguous-response-root', payload);
+    const wrapper = wrappers[0];
+    attrs(wrapper, true);
+    const parameters = elements(wrapper);
+    if (parameters.length !== root.parts.length)
+        return fail('mismatch', 'rpc-result-accessor-count', wrapper);
+    const visited = new Set([wrapper]);
+    const stringValue = (initial) => {
+        const chain = new Set();
+        let node = initial, inheritedType = true;
+        // @constraints Flat local-reference chains must not consume the JavaScript call stack.
+        for (;;) {
+            check();
+            budget.chargeWork(32 + node.children.length * 8);
+            attrs(node);
+            if (chain.has(node))
+                return fail('unsupported', 'rpc-cyclic-reference', node);
+            chain.add(node);
+            visited.add(node);
+            const explicit = syntaxAttribute(node, 'type', XSI);
+            const implicit = node.name.namespace === ENC && node.name.local === 'string';
+            if (node.name.namespace === ENC && !implicit)
+                return fail('unsupported', 'rpc-string-type', node);
+            if (explicit !== undefined) {
+                let type;
+                try {
+                    type = resolveLexicalQName(explicit, node);
+                }
+                catch {
+                    return fail('unsupported', 'rpc-string-type', node);
+                }
+                if (type.local !== 'string' || type.namespace !== XSD_NAMESPACE && type.namespace !== ENC)
+                    return fail('unsupported', 'rpc-string-type', node);
+            }
+            else if (!inheritedType && !implicit)
+                return fail('unsupported', 'rpc-string-type-required', node);
+            const href = syntaxAttribute(node, 'href');
+            if (href !== undefined) {
+                if (syntaxElements(node).length || node.children.some(c => c.kind === 'text' && /[^\t\r\n ]/.test(c.value)))
+                    return fail('mismatch', 'rpc-reference-content', node);
+                if (!href.startsWith('#') || !isXmlNCName(href.slice(1)))
+                    return fail('unsupported', 'rpc-local-reference-required', node);
+                const target = ids.get(href.slice(1));
+                if (!target)
+                    return fail('mismatch', 'rpc-dangling-reference', node);
+                node = target;
+                inheritedType = false;
+                continue;
+            }
+            if (syntaxElements(node).length)
+                return fail('unsupported', 'rpc-string-compound-value', node);
+            const value = node.children.map(c => c.kind === 'text' ? c.value : '').join('');
+            budget.chargeWork(32 + value.length * 8);
+            return value;
+        }
+    };
+    const result = Object.create(null);
+    root.parts.forEach((part, index) => {
+        check();
+        const accessor = parameters[index];
+        if (accessor.name.namespace !== '' || !output && accessor.name.local !== part.name)
+            return fail('mismatch', 'rpc-parameter-name-order', accessor);
+        if (rootMarker(accessor) !== undefined)
+            return fail('unsupported', 'rpc-accessor-root-marker', accessor);
+        result[part.name] = stringValue(accessor);
+    });
+    for (const independent of top) {
+        check();
+        if (independent === wrapper)
+            continue;
+        if (!visited.has(independent) || rootMarker(independent) === '1')
+            return fail('mismatch', 'rpc-unexpected-body-content', independent);
+    }
+    return result;
+}