@techspokes/typescript-wsdl-client 1.1.8 → 1.3.0

package/dist/client/generateOperations.js

@@ -4,6 +4,7 @@
  * Generates a fully-typed operations interface for the SOAP client.
  * This standalone interface enables mocking and testing without importing
  * the concrete SOAP client class or its runtime dependencies.
+ * @since Unreleased
  */
 import { writeGeneratedSource } from "../generation/writeGeneratedSource.js";
 import { deriveClientName, pascal } from "../util/tools.js";
@@ -31,18 +32,25 @@ export function generateOperations(outFile, compiled) {
         .map(line => line.replace(/\*\//g, "*\\/"));
     // Collect type names used in method signatures for the import statement
     const importedTypes = new Set();
+    const operationTypes = compiled.operations.map(operation => ({ operation,
+        input: operation.inputTypeName ?? (operation.inputElement ? pascal(operation.inputElement.local) : undefined),
+        output: operation.outputTypeName ?? (operation.outputElement ? pascal(operation.outputElement.local) : undefined),
+    }));
+    const reservedTypes = new Set(["Promise", "AsyncIterable", "AbortSignal", "StreamCallOptions", "StreamOperationResponse", `${clientName}Operations`]);
+    // @constraints Qualify model references when their public names overlap generated helpers or native transport types.
+    const namespaceModels = operationTypes.some(({ operation, input, output }) => [input, output, operation.stream?.recordTypeName].some(name => name !== undefined && reservedTypes.has(name)));
+    const modelType = (name) => namespaceModels ? `T.${name}` : name;
     const methods = [];
     // Does any operation opt into streaming? If so we also emit the
     // StreamOperationResponse helper type below.
     let anyStream = false;
-    for (const op of compiled.operations) {
-        const inTypeName = op.inputTypeName ?? (op.inputElement ? pascal(op.inputElement.local) : undefined);
-        const outTypeName = op.outputTypeName ?? (op.outputElement ? pascal(op.outputElement.local) : undefined);
+    for (const { operation: op, input: inTypeName, output: outTypeName } of operationTypes) {
         if (!inTypeName && !outTypeName) {
             continue;
         }
-        const inTs = inTypeName ?? "Record<string, unknown>";
-        const outTs = outTypeName ?? "unknown";
+        // @constraints WSDL DTOs may be named Record and shadow the built-in utility type.
+        const inTs = inTypeName ? modelType(inTypeName) : "{[key: string]: unknown}";
+        const outTs = outTypeName ? modelType(outTypeName) : "unknown";
         if (inTypeName)
             importedTypes.add(inTypeName);
         if (outTypeName)
@@ -56,8 +64,9 @@ export function generateOperations(outFile, compiled) {
             const recordTs = op.stream.recordTypeName;
             importedTypes.add(recordTs);
             methods.push(`${docBlock}  ${op.name}(\n` +
-                `    args: ${inTs}\n` +
-                `  ): Promise<StreamOperationResponse<${recordTs}>>;\n`);
+                `    args: ${inTs},\n` +
+                `    options?: StreamCallOptions\n` +
+                `  ): Promise<StreamOperationResponse<${modelType(recordTs)}>>;\n`);
         }
         else {
             methods.push(`${docBlock}  ${op.name}(\n` +
@@ -68,16 +77,26 @@ export function generateOperations(outFile, compiled) {
     // Build sorted import list for deterministic output
     const sortedImports = Array.from(importedTypes).sort();
     const typeImport = sortedImports.length > 0
-        ? `import type {\n${sortedImports.map((t) => `  ${t},`).join("\n")}\n} from "./types${suffix}";\n\n`
+        ? namespaceModels
+            ? `import type * as T from "./types${suffix}";\n\n`
+            : `import type {\n${sortedImports.map((t) => `  ${t},`).join("\n")}\n} from "./types${suffix}";\n\n`
         : "";
     // Emit the StreamOperationResponse helper type iff at least one operation
     // is stream-configured. Kept inside operations.ts so that mocks and gateway
     // code can import it without pulling in the SOAP runtime. The raw template
     // lives in a sibling .tpl file so the IDE does not try to parse embedded
-    // TypeScript type-parameter defaults (HeadersType = Record<...>) as
-    // JavaScript assignment expressions.
+    // TypeScript generic defaults as JavaScript assignment expressions.
     const streamHelper = anyStream
-        ? loadRuntimeSource("operationsStreamHelper.tpl.txt").replace(/__CLIENT_NAME__/g, clientName)
+        ? `/**
+ * Per-call stream cancellation and total request/response deadline.
+ * @since Unreleased
+ */
+export interface StreamCallOptions {
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+
+` + loadRuntimeSource("operationsStreamHelper.tpl.txt").replace(/__CLIENT_NAME__/g, clientName)
         : "";
     const content = `/**
  * Typed operations interface for the ${clientName} service.

package/dist/client/generateUtils.js

@@ -48,7 +48,9 @@ export function generateUtils(outFile, compiled) {
             return max === "unbounded" || (typeof max === "number" && max > 1);
         }).sort(),
     ]));
-    const metas = JSON.stringify({ Attributes: attrSpec, AttributeTypes: compiled.meta.attrType ?? {}, ChildrenTypes: childType, RepeatedElements: repeatedElements }, null, 2);
+    const metas = JSON.stringify({ Attributes: attrSpec, AttributeTypes: compiled.meta.attrType ?? {}, ChildrenTypes: childType, RepeatedElements: repeatedElements,
+        NonNillableElements: Object.fromEntries(Object.entries(compiled.meta.propMeta ?? {}).sort(([a], [b]) => a.localeCompare(b))
+            .map(([name, properties]) => [name, Object.keys(properties).filter(key => properties[key].nillable === false).sort()])) }, null, 2);
     const dataTypes = `/**
  * ${clientName} WSDL data types for proper serialization/deserialization.
  * Used to distinguish between XML attributes and elements during conversion.
@@ -62,6 +64,8 @@ export interface ${clientName}DataTypes {
   ChildrenTypes: Record<string, Readonly<Record<string, string>>>;
   /** Maps type names to repeated child properties; optional for custom metadata compatibility. */
   RepeatedElements?: Record<string, readonly string[]>;
+  /** Distinguishes empty complex nodes collapsed to null by node-soap from declared nullable children. */
+  NonNillableElements?: Record<string, readonly string[]>;
 }
 
 export const ${clientConstant}_DATA_TYPES: ${clientName}DataTypes = ${metas} as const;\n`;

package/dist/compiler/canonicalGraph.d.ts

@@ -1,19 +1,11 @@
+/** Internal, language-neutral S04 contract. S05 resolves and composes these references. */
+import type { Identity, NodeId, SymbolRole } from "./declarationIdentity.js";
+export { globalId, scopedId } from "./declarationIdentity.js";
+export type { Identity, NodeId, SymbolRole } from "./declarationIdentity.js";
 import type { ExpandedName, SyntaxAttribute, SyntaxElement, SyntaxSource } from "../loader/orderedSyntax.js";
 export declare const GRAPH_MODEL: "xsd10-faithful-v1";
 export declare const DEFAULT_GRAPH_NODES = 100000;
 export declare const isBuiltinType: (local: string) => boolean;
-export type NodeId = string;
-export type SymbolRole = "element" | "attribute" | "type" | "group" | "attributeGroup" | "message" | "portType" | "binding" | "service";
-export type Identity = Readonly<{
-    kind: "global";
-    role: SymbolRole;
-    name: ExpandedName;
-} | {
-    kind: "scoped";
-    owner: NodeId;
-    path: string;
-    role: string;
-}>;
 export type GraphContext = Readonly<{
     namespaces: Readonly<Record<string, string>>;
     baseUri: string;
@@ -190,8 +182,5 @@ export declare class GraphError extends Error {
     readonly source?: SyntaxSource | undefined;
     constructor(category: "invalid-schema" | "resource-limit", message: string, source?: SyntaxSource | undefined);
 }
-export declare function globalId(role: SymbolRole, name: ExpandedName): NodeId;
-export declare function scopedId(owner: NodeId, path: string, role: string): NodeId;
 export declare function wsdlReferenceRoles(node: SyntaxElement): Record<string, SymbolRole>;
 export declare function deepFreeze<T>(value: T): T;
-export {};

package/dist/compiler/canonicalGraph.js

@@ -1,5 +1,4 @@
-/** Internal, language-neutral S04 contract. S05 resolves and composes these references. */
-import { createHash } from "node:crypto";
+export { globalId, scopedId } from "./declarationIdentity.js";
 import { WSDL_NAMESPACE } from "../loader/orderedSyntax.js";
 export const GRAPH_MODEL = "xsd10-faithful-v1";
 export const DEFAULT_GRAPH_NODES = 100_000;
@@ -15,12 +14,6 @@ export class GraphError extends Error {
         this.name = "GraphError";
     }
 }
-export function globalId(role, name) {
-    return JSON.stringify(["global", role, name.namespace, name.local]);
-}
-export function scopedId(owner, path, role) {
-    return "scoped:" + createHash("sha256").update(JSON.stringify([owner, path, role])).digest("hex");
-}
 export function wsdlReferenceRoles(node) {
     if (node.name.namespace !== WSDL_NAMESPACE)
         return {};

package/dist/compiler/componentRecordProjection.d.ts

@@ -101,6 +101,9 @@ export declare function decodeComponentRecordXml(outer: DirectOperationContract,
     signal?: AbortSignal;
     limits?: DirectXmlLimits;
     uri?: string;
+    componentResponseEncoding?: {
+        charset?: string;
+    };
     selectPayload?: (root: SyntaxElement) => {
         payload: SyntaxElement;
         mapping: ComponentRecordProjection | ComponentValueMapping;

package/dist/compiler/componentRecordProjection.js

@@ -46,6 +46,8 @@ export function createComponentRecordProjection(outer, companion, supplied, opti
     try {
         const result = budget.guard(() => {
             check();
+            if ('parts' in outer.output || 'parts' in companion.output)
+                return failure('unsupported', 'record-projection-requires-document-output');
             if (outer.basis !== 'native-component-premises-v1' || companion.basis !== 'native-component-premises-v1'
                 || outer.correspondence !== 'dated-XSD-2004-components-v1' || companion.correspondence !== 'dated-XSD-2004-components-v1')
                 stop('component-record-source-authority');
@@ -75,6 +77,8 @@ export function createComponentRecordProjection(outer, companion, supplied, opti
             if (mapping.kind !== 'component-mapping')
                 return mapping;
             const projection = inspectComponentValueMapping(mapping, companion).projection;
+            if (!projection)
+                return failure('unsupported', 'record-projection-requires-document-mapping');
             const records = new Map(projection.records.map(record => [record.type.id, record]));
             if (association && !Object.hasOwn(requested, 'recordPath')) {
                 const candidates = [];
@@ -226,6 +230,8 @@ export function inspectComponentRecordValue(value, projection) {
  */
 export function validateComponentRecordApplication(projection, application, options = {}) {
     const owned = inspectComponentRecordProjection(projection), { context } = inspectDirectOperation(owned.companion);
+    if ('parts' in owned.mapping.root)
+        throw new TypeError('Record projection requires a document mapping');
     return expandProjectionValue(context, owned.mapping.root.element, application, options);
 }
 /** Decode once and validate the declared wrapper plus its explicitly selected companion payload.
@@ -253,6 +259,8 @@ export function decodeComponentRecordXml(outer, projection, bytes, options = {})
                 return assessObservedComponentPayload(outer, mapping, observation, selected.payload, options);
             }
             const wrapper = selected.payload;
+            if ('parts' in outer.output)
+                throw new ScopeStop('unsupported', 'record-projection-requires-document-output');
             if (!same(wrapper.name, outer.output.element.name))
                 throw new ScopeStop('mismatch', 'record-wrapper-root');
             if (wrapper.attributes.length || wrapper.children.some(node => node.kind === 'text' && /[^\t\r\n ]/.test(node.value)))
@@ -284,6 +292,8 @@ export function decodeComponentRecordXml(outer, projection, bytes, options = {})
             const decoded = assessObservedComponentPayload(owned.companion, owned.mapping, observation, payload, options);
             if (decoded.kind !== 'component-decoded')
                 return decoded;
+            if (decoded.validated.kind !== 'projection-value')
+                throw new TypeError('Record projection requires a document value receipt');
             const recordCount = countRecords(observation, payload, projection.spec.recordPath, check);
             const validated = Object.freeze({ kind: 'component-record-value', scope: 'records-with-declared-wrapper-scope',
                 admitted: false, value: decoded.validated.value, recordCount, companion: decoded.validated });

package/dist/compiler/declarationIdentity.d.ts

@@ -0,0 +1,22 @@
+export type NodeId = string;
+export type SymbolRole = "element" | "attribute" | "type" | "group" | "attributeGroup" | "message" | "portType" | "binding" | "service";
+export type Identity = Readonly<{
+    kind: "global";
+    role: SymbolRole;
+    name: Readonly<{
+        namespace: string;
+        local: string;
+    }>;
+} | {
+    kind: "scoped";
+    owner: NodeId;
+    path: string;
+    role: string;
+}>;
+/** Encode XML symbol identity independently of source location and emitted language names. */
+export declare function globalId(role: SymbolRole, name: Readonly<{
+    namespace: string;
+    local: string;
+}>): NodeId;
+/** Encode a declaration within its owner's scope using the caller's structural path convention. */
+export declare function scopedId(owner: NodeId, path: string, role: string): NodeId;

package/dist/compiler/declarationIdentity.js

@@ -0,0 +1,9 @@
+import { createHash } from "node:crypto";
+/** Encode XML symbol identity independently of source location and emitted language names. */
+export function globalId(role, name) {
+    return JSON.stringify(["global", role, name.namespace, name.local]);
+}
+/** Encode a declaration within its owner's scope using the caller's structural path convention. */
+export function scopedId(owner, path, role) {
+    return "scoped:" + createHash("sha256").update(JSON.stringify([owner, path, role])).digest("hex");
+}

package/dist/compiler/directCodec.d.ts

@@ -2,6 +2,7 @@ import type { DirectOperationContract } from './directOperation.js';
 import type { DirectValueMapping, DirectValueReceipt, DirectValueFailure, DirectExpandedValue, ComponentValueMapping, ProjectionExpandedValue, ProjectionValueReceipt } from './directValues.js';
 import type { SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
 import type { ResolverUsage } from './semanticBudget.js';
+import type { RpcTypedValue } from './rpcTypedValues.js';
 export interface DirectXmlLimits {
     readonly maxBytes?: number;
     readonly maxDepth?: number;
@@ -53,7 +54,7 @@ export interface ComponentEncodedXml {
     readonly admitted: false;
     readonly encoding: 'utf-8';
     readonly bytes: Uint8Array;
-    readonly expanded: ProjectionExpandedValue;
+    readonly expanded: ProjectionExpandedValue | RpcExpandedValue;
     readonly mapping: ComponentValueMapping;
     readonly usage: ResolverUsage;
 }
@@ -61,10 +62,23 @@ export interface ComponentDecodedXml {
     readonly kind: 'component-decoded';
     readonly admitted: false;
     readonly payload: SyntaxElement;
-    readonly validated: ProjectionValueReceipt;
+    readonly validated: ProjectionValueReceipt | RpcValueReceipt;
     readonly mapping: ComponentValueMapping;
     readonly usage: ResolverUsage;
 }
+export interface RpcValueReceipt {
+    readonly kind: 'rpc-string-value' | 'rpc-typed-value';
+    readonly admitted: false;
+    readonly value: RpcTypedValue;
+    readonly usage: ResolverUsage;
+}
+export interface RpcExpandedValue {
+    readonly kind: 'rpc-string-expanded' | 'rpc-typed-expanded';
+    readonly admitted: false;
+    readonly payload: SyntaxElement;
+    readonly validated: RpcValueReceipt;
+    readonly usage: ResolverUsage;
+}
 export interface ComponentPayloadSelection {
     readonly payload: SyntaxElement;
     readonly mapping: ComponentValueMapping;
@@ -88,6 +102,9 @@ export declare function encodeComponentXml(contract: DirectOperationContract, ma
  */
 export declare function observeComponentXml(contract: DirectOperationContract, mapping: unknown, bytes: Uint8Array, options?: Options & Readonly<{
     uri?: string;
+    componentResponseEncoding?: {
+        charset?: string;
+    };
 }>): ComponentXmlObservation | DirectCodecFailure;
 /** 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
@@ -111,6 +128,9 @@ export declare function decodeDirectXml(contract: DirectOperationContract, mappi
  */
 export declare function decodeComponentXml(contract: DirectOperationContract, mapping: unknown, bytes: Uint8Array, options?: Options & Readonly<{
     uri?: string;
+    componentResponseEncoding?: {
+        charset?: string;
+    };
     selectPayload?: (root: SyntaxElement) => ComponentPayloadSelection;
 }>): ComponentDecodedXml | DirectCodecFailure;
 export {};

package/dist/compiler/directCodec.js

@@ -3,11 +3,13 @@ import { directDataOwnership, directLimit } from './directExecutionPolicy.js';
 import { checkSemanticBudget } from './semanticBudget.js';
 import { DataOwnershipLimitError } from './dataOwnership.js';
 import { types } from 'node:util';
-import { inspectDirectOperation } from './directOperation.js';
+import { inspectDirectOperation, isRpcMessageRoot } from './directOperation.js';
 import { inspectDirectValueMapping, expandDirectValue, assessDirectScalars, inspectComponentValueMapping, expandProjectionValue, assessProjectionScalars } from './directValues.js';
 import { matchDirectOperation, matchDirectProjection } from './directStructure.js';
 import { parseOrderedSyntax, SchemaLoadingError, XML_NAMESPACE } from '../loader/orderedSyntax.js';
 import { isXmlNamespaceBinding } from './directStructurePlan.js';
+import { expandRpcStrings, readRpcStrings } from './rpcStringValues.js';
+import { expandRpcTyped, readRpcTyped } from './rpcTypedValues.js';
 export const DIRECT_XML_LIMITS = Object.freeze({ maxBytes: 1024 * 1024, maxDepth: 256, maxNodes: 100_000, maxText: 1024 * 1024 });
 const componentObservations = new WeakSet();
 class Stop extends Error {
@@ -34,9 +36,11 @@ function runMapping(contract, supplied, options, profile, inspect, work) {
     try {
         const result = budget.guard(() => {
             check();
-            if (mapping.version !== profile.version || mapping.contextId !== contract.contextId
+            const rpc = profile === componentProfile && (mapping.version === 'component-rpc-string-values-v1' || mapping.version === 'component-rpc-typed-values-v1') && isRpcMessageRoot(mapping.root)
+                && contract.binding.style === 'rpc' && contract.binding.use === 'encoded' && contract.binding.encoding === 'http://schemas.xmlsoap.org/soap/encoding/';
+            if ((!rpc && mapping.version !== profile.version) || mapping.contextId !== contract.contextId
                 || contract.basis !== profile.basis || contract.correspondence !== profile.correspondence
-                || contract.binding.version !== '1.1' || contract.binding.style !== 'document' || contract.binding.use !== 'literal'
+                || !(contract.binding.version === '1.1' || profile === componentProfile && contract.binding.version === '1.2' && !rpc) || !rpc && (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;
@@ -235,6 +239,16 @@ export function encodeDirectXml(contract, mapping, application, options = {}) {
 export function encodeComponentXml(contract, mapping, application, options = {}) {
     return runComponent(contract, mapping, options, (owned, session) => {
         const { context } = inspectDirectOperation(contract), { budget, limits } = session;
+        if (isRpcMessageRoot(owned.root)) {
+            const control = { ...session, fail: (kind, rule, node) => { throw new Stop(kind, rule, node?.source); } };
+            const { rpcParts } = inspectComponentValueMapping(owned, contract);
+            const result = rpcParts ? expandRpcTyped(context, owned.root, rpcParts, application, control) : expandRpcStrings(owned.root, application, control);
+            const validated = { kind: rpcParts ? 'rpc-typed-value' : 'rpc-string-value', admitted: false, value: result.value, usage: budget.usage() };
+            const expanded = { kind: rpcParts ? 'rpc-typed-expanded' : 'rpc-string-expanded', admitted: false, payload: result.payload, validated, usage: budget.usage() };
+            directDataOwnership(budget).freeze(expanded);
+            const bytes = emitObservedXml(result.payload, session);
+            return Object.freeze({ kind: 'component-encoded', admitted: false, encoding: 'utf-8', bytes, expanded, mapping: owned, usage: budget.usage() });
+        }
         // @why Application items include attributes; XML syntax-node/text caps count elements and character data.
         //   Encoded bytes bound inverse input capacity without treating those different counters as equal.
         const expanded = expandProjectionValue(context, owned.root.element, application, { ...options,
@@ -247,7 +261,7 @@ export function encodeComponentXml(contract, mapping, application, options = {})
     });
 }
 /** Retain the shared byte-copy, XML-version, entity and explicit capacity boundaries for both profiles. */
-function parseObservedXml(bytes, { budget, limits, check }, sourceUri) {
+function parseObservedXml(bytes, { budget, limits, check }, sourceUri, componentResponseEncoding) {
     if (!types.isUint8Array(bytes) || types.isProxy(bytes))
         throw new TypeError('XML requires Uint8Array bytes');
     // Use native internal-slot access, avoiding subclass/own length, buffer and
@@ -266,7 +280,7 @@ function parseObservedXml(bytes, { budget, limits, check }, sourceUri) {
     if (typeof uri !== 'string')
         throw new TypeError('XML source URI must be a string');
     check();
-    return parseOrderedSyntax(input, uri, { ...limits, xml10Only: true,
+    return parseOrderedSyntax(input, uri, { ...limits, xml10Only: true, componentResponseEncoding,
         chargeWork: () => check(), reserveNode: () => { check(); budget.reserveNodes(1); } }).root;
 }
 function assertObservedPayload(root, payload, check) {
@@ -291,7 +305,7 @@ function assertObservedPayload(root, payload, check) {
  */
 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');
+        const root = parseObservedXml(bytes, session, options.uri ?? 'urn:typescript-wsdl-client:observed-component-xml', options.componentResponseEncoding);
         directDataOwnership(session.budget).freeze(root);
         return Object.freeze({ kind: 'observed-component-xml', root, usage: Object.freeze({ ...session.budget.usage() }) });
     });
@@ -310,6 +324,15 @@ export function assessObservedComponentPayload(contract, mapping, observation, p
     return runComponent(contract, mapping, options, (owned, { budget, check }) => {
         assertObservedPayload(observation.root, payload, check);
         const { context } = inspectDirectOperation(contract);
+        if (isRpcMessageRoot(owned.root)) {
+            const control = { budget, check, fail: (kind, rule, node) => { throw new Stop(kind, rule, node?.source); } };
+            const { rpcParts } = inspectComponentValueMapping(owned, contract);
+            const value = rpcParts && owned.direction.kind === 'input' ? readRpcTyped(context, owned.root, rpcParts, payload, control)
+                : readRpcStrings(owned.root, payload, owned.direction.kind === 'output', control);
+            const validated = { kind: rpcParts ? 'rpc-typed-value' : 'rpc-string-value', admitted: false, value, usage: budget.usage() };
+            directDataOwnership(budget).freeze(validated);
+            return { kind: 'component-decoded', admitted: false, payload, validated, mapping: owned, usage: budget.usage() };
+        }
         const structural = matchDirectProjection(context, owned.root.element, payload, options);
         if (structural.kind !== 'projection-match')
             return structural;
@@ -358,10 +381,20 @@ export function decodeDirectXml(contract, mapping, bytes, options = {}) {
 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 root = parseObservedXml(bytes, session, options.uri ?? 'urn:typescript-wsdl-client:observed-component-xml', options.componentResponseEncoding);
         const selection = options.selectPayload?.(root) ?? { payload: root, mapping: owned };
         const selected = inspectComponentValueMapping(selection.mapping, contract).mapping;
         assertObservedPayload(root, selection.payload, check);
+        if (isRpcMessageRoot(selected.root)) {
+            const control = { ...session, fail: (kind, rule, node) => { throw new Stop(kind, rule, node?.source); } };
+            const { rpcParts } = inspectComponentValueMapping(selected, contract);
+            const value = rpcParts && selected.direction.kind === 'input' ? readRpcTyped(context, selected.root, rpcParts, selection.payload, control)
+                : readRpcStrings(selected.root, selection.payload, selected.direction.kind === 'output', control);
+            const validated = { kind: rpcParts ? 'rpc-typed-value' : 'rpc-string-value', admitted: false, value, usage: budget.usage() };
+            directDataOwnership(budget).freeze(validated);
+            directDataOwnership(budget).freeze(selection.payload);
+            return { kind: 'component-decoded', admitted: false, payload: selection.payload, validated, mapping: selected, usage: budget.usage() };
+        }
         const structural = matchDirectProjection(context, selected.root.element, selection.payload, options);
         if (structural.kind !== 'projection-match')
             return structural;

package/dist/compiler/directOperation.d.ts

@@ -19,21 +19,44 @@ export interface DirectMessageRoot {
     readonly type: Reference;
     readonly source: SyntaxSource;
 }
+/** Source-owned RPC parameters; these are WSDL parts rather than schema element declarations.
+ * @since 1.1.9
+ */
+export interface RpcMessageRoot {
+    readonly kind: 'rpc-typed-parts-v1';
+    readonly message: ExpandedName;
+    readonly parts: readonly Readonly<{
+        name: string;
+        type: Reference;
+        source: SyntaxSource;
+    }>[];
+    readonly wrapper: ExpandedName;
+    readonly bodyNamespace: string;
+    readonly encoding: 'http://schemas.xmlsoap.org/soap/encoding/';
+    readonly source: SyntaxSource;
+}
+/** Distinguish typed RPC parameters without inventing a document element.
+ * @param root Selected native message.
+ * @returns Whether the message uses the bounded RPC profile.
+ */
+export declare function isRpcMessageRoot(root: DirectMessageRoot | RpcMessageRoot): root is RpcMessageRoot;
 export interface DirectOperationContract {
     readonly selector: DirectOperationSelector;
     readonly contextId: string;
     readonly basis: 'native-direct-premises-v1' | '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';
+        version: '1.1' | '1.2';
+        style: 'document' | 'rpc';
+        use: 'literal' | 'encoded';
+        encoding?: string;
         transport: string;
         action: string;
+        actionRequired?: boolean;
         source: SyntaxSource;
     }>;
-    readonly input: DirectMessageRoot;
-    readonly output: DirectMessageRoot;
+    readonly input: DirectMessageRoot | RpcMessageRoot;
+    readonly output: DirectMessageRoot | RpcMessageRoot;
     readonly faults: readonly Readonly<{
         name: string;
         root: DirectMessageRoot;