@techspokes/typescript-wsdl-client 1.1.8 → 1.2.0

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' || !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,6 +19,27 @@ 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;
@@ -26,14 +47,15 @@ export interface DirectOperationContract {
     readonly correspondence: 'dated-XSD-2004-direct-v1' | 'dated-XSD-2004-components-v1';
     readonly binding: Readonly<{
         version: '1.1';
-        style: 'document';
-        use: 'literal';
+        style: 'document' | 'rpc';
+        use: 'literal' | 'encoded';
+        encoding?: string;
         transport: string;
         action: string;
         source: SyntaxSource;
     }>;
-    readonly input: DirectMessageRoot;
-    readonly output: DirectMessageRoot;
+    readonly input: DirectMessageRoot | RpcMessageRoot;
+    readonly output: DirectMessageRoot | RpcMessageRoot;
     readonly faults: readonly Readonly<{
         name: string;
         root: DirectMessageRoot;

package/dist/compiler/directOperation.js

@@ -1,7 +1,7 @@
 import { directLimit, directLoadingLimits } from './directExecutionPolicy.js';
 /** Transient source-owned schema selection. This module grants no runtime admission. */
 import { loadSemanticSchemaInput } from '../loader/schemaInput.js';
-import { SchemaLoadingError, WSDL_NAMESPACE, syntaxAttribute, syntaxElements, isXmlNCName } from '../loader/orderedSyntax.js';
+import { SchemaLoadingError, WSDL_NAMESPACE, XSD_NAMESPACE, syntaxAttribute, syntaxElements, isXmlNCName } from '../loader/orderedSyntax.js';
 import { globalId } from './canonicalGraph.js';
 import { createApplicationBudget, DEFAULT_MAX_NODES } from './semanticBudget.js';
 import { qualifyDirectSource } from './checkedSourcePreparation.js';
@@ -10,6 +10,13 @@ import { prepareWsdlPolicyRequirements, assertWsdlPolicyRequirements } from './w
 const SOAP = 'http://schemas.xmlsoap.org/wsdl/soap/';
 const HTTP = 'http://schemas.xmlsoap.org/soap/http';
 const ADDRESSING_WSDL = 'http://www.w3.org/2006/05/addressing/wsdl';
+/** Distinguish typed RPC parameters without inventing a document element.
+ * @param root Selected native message.
+ * @returns Whether the message uses the bounded RPC profile.
+ */
+export function isRpcMessageRoot(root) {
+    return 'kind' in root && root.kind === 'rpc-typed-parts-v1';
+}
 const issued = new WeakMap();
 /** Object identity authenticates the exact issued roots; context IDs and digests do not. */
 export function inspectDirectOperation(contract, expectedContext) {
@@ -181,7 +188,7 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                 portType: ['name'], operation: ['name', 'parameterOrder'], input: ['name', 'message'], output: ['name', 'message'], fault: ['name', 'message'],
                 binding: ['name', 'type'], service: ['name'], port: ['name', 'binding'],
             };
-            const soapAttributes = { binding: ['style', 'transport'], operation: ['soapAction', 'style'], body: ['use', 'parts'], fault: ['name', 'use'], address: ['location'] };
+            const soapAttributes = { binding: ['style', 'transport'], operation: ['soapAction', 'style'], body: profile === 'components' ? ['use', 'parts', 'namespace', 'encodingStyle'] : ['use', 'parts'], fault: ['name', 'use'], address: ['location'] };
             for (const document of input.documents) {
                 const stack = [document.root];
                 while (stack.length) {
@@ -256,7 +263,8 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                 return refuse('unsupported', 'soap-binding-style');
             if (attr(soapBinding, 'transport') !== HTTP)
                 return refuse('unsupported', 'soap-transport');
-            if ((attr(soapOperation, 'style') ?? attr(soapBinding, 'style') ?? 'document') !== 'document')
+            const style = attr(soapOperation, 'style') ?? attr(soapBinding, 'style') ?? 'document';
+            if (style !== 'document' && !(profile === 'components' && style === 'rpc'))
                 return refuse('unsupported', 'soap-style');
             const action = attr(soapOperation, 'soapAction');
             if (action === undefined)
@@ -283,6 +291,7 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                 shape(boundSyntax, [soap(faultName === undefined ? 'body' : 'fault'), ws('documentation')]);
                 const body = exactly(boundSyntax, SOAP, faultName === undefined ? 'body' : 'fault');
                 shape(body, []);
+                attrs(body, faultName === undefined ? ['use', 'parts'] : ['use', 'name']);
                 if (attr(body, 'use') !== 'literal')
                     return refuse('unsupported', 'literal-required');
                 if (faultName !== undefined && attr(body, 'name') !== faultName)
@@ -309,17 +318,61 @@ async function selectOperationInRequest(source, selector, options, budget, profi
                     return refuse('selection-refused', 'element-type');
                 return Object.freeze({ message: message.name, part: partName, element, type: element.type, source: part.source });
             };
+            const rpcRoot = (messageSyntax, boundSyntax, direction) => {
+                attrs(messageSyntax, ['name', 'message']);
+                attrs(boundSyntax, ['name']);
+                shape(messageSyntax, [ws('documentation')]);
+                shape(boundSyntax, [soap('body'), ws('documentation')]);
+                const body = exactly(boundSyntax, SOAP, 'body');
+                shape(body, []);
+                const encoding = 'http://schemas.xmlsoap.org/soap/encoding/';
+                if (attr(body, 'use') !== 'encoded' || attr(body, 'encodingStyle')?.trim() !== encoding)
+                    return refuse('unsupported', 'rpc-string-encoding');
+                const bodyNamespace = attr(body, 'namespace');
+                if (!bodyNamespace || !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(bodyNamespace))
+                    return refuse('unsupported', 'rpc-body-namespace');
+                const message = reference(portType, messageSyntax, 'message');
+                if (message.kind !== 'wsdl' || message.role !== 'message')
+                    return refuse('selection-refused', 'message-reference');
+                shape(message.syntax, [ws('part'), ws('documentation')]);
+                const declared = children(message.syntax).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'part');
+                if (!declared.length || direction === 'output' && declared.length !== 1)
+                    return refuse('unsupported', 'rpc-single-string-result');
+                const names = new Set();
+                const parts = declared.map(part => {
+                    attrs(part, ['name', 'type']);
+                    shape(part, [ws('documentation')]);
+                    const name = attr(part, 'name');
+                    if (!name || !isXmlNCName(name) || names.has(name))
+                        return refuse('selection-refused', 'rpc-part-name');
+                    names.add(name);
+                    const path = part.source.path.slice(message.syntax.source.path.length) || '/';
+                    const refs = message.references.filter(r => r.path === path && r.attribute === 'type');
+                    if (refs.length !== 1)
+                        return refuse('unsupported', 'rpc-part-type-required');
+                    const resolved = context.resolve(refs[0].reference);
+                    if (direction === 'output' && (resolved.kind !== 'builtin' || resolved.name.namespace !== XSD_NAMESPACE || resolved.name.local !== 'string'))
+                        return refuse('unsupported', 'rpc-string-part-required');
+                    return Object.freeze({ name, type: refs[0].reference, source: part.source });
+                });
+                if (attr(body, 'parts') !== undefined && attr(body, 'parts').trim().split(/[\t\r\n ]+/).join(' ') !== parts.map(p => p.name).join(' '))
+                    return refuse('unsupported', 'rpc-body-parts');
+                return Object.freeze({ kind: 'rpc-typed-parts-v1', message: message.name, parts, bodyNamespace, encoding,
+                    wrapper: { namespace: bodyNamespace, local: ownedSelector.operation + (direction === 'output' ? 'Response' : '') }, source: body.source });
+            };
             const io = (direction, declaration) => {
                 const boundIo = exactly(bound, WSDL_NAMESPACE, direction);
                 const boundName = attr(boundIo, 'name');
                 const expectedName = attr(declaration, 'name') ?? `${ownedSelector.operation}${direction === 'input' ? 'Request' : 'Response'}`;
                 if (boundName !== undefined && boundName !== expectedName)
                     return refuse('selection-refused', 'binding-message-name');
-                return root(declaration, boundIo);
+                return style === 'rpc' ? rpcRoot(declaration, boundIo, direction) : root(declaration, boundIo);
             };
             const requestRoot = io('input', abstractInput), responseRoot = io('output', abstractOutput);
             const declaredFaults = children(abstract).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'fault');
             const boundFaults = children(bound).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'fault');
+            if (style === 'rpc' && (declaredFaults.length || boundFaults.length))
+                return refuse('unsupported', 'rpc-declared-fault');
             if (declaredFaults.length !== boundFaults.length)
                 return refuse('selection-refused', 'fault-mapping');
             const faultNames = new Set();
@@ -340,7 +393,8 @@ async function selectOperationInRequest(source, selector, options, budget, profi
             const contract = { selector: ownedSelector, contextId: context.contextId,
                 basis: profile === 'direct' ? 'native-direct-premises-v1' : 'native-component-premises-v1',
                 correspondence: profile === 'direct' ? 'dated-XSD-2004-direct-v1' : 'dated-XSD-2004-components-v1',
-                binding: { version: '1.1', style: 'document', use: 'literal', transport: HTTP, action, source: binding.context.source },
+                binding: { version: '1.1', style: style, use: style === 'rpc' ? 'encoded' : 'literal',
+                    ...(style === 'rpc' ? { encoding: 'http://schemas.xmlsoap.org/soap/encoding/' } : {}), transport: HTTP, action, source: binding.context.source },
                 input: requestRoot, output: responseRoot, faults,
                 ...(policyOwner ? { policy: policyOwner.forBinding(binding.syntax), addressingActions: { required: false,
                         input: attr(abstractInput, 'Action', ADDRESSING_WSDL), output: attr(abstractOutput, 'Action', ADDRESSING_WSDL),

package/dist/compiler/directSoap.js

@@ -171,6 +171,7 @@ async function exchangeSoap(contract, input, application, options, profile) {
             && (typeof allowEndpoint !== 'function' || allowEndpoint(new URL(endpoint.href)) !== true))
             return fail('unsupported', 'endpoint authorization');
         const action = contract.binding.action;
+        const rpc = contract.binding.style === 'rpc';
         if (/[^\x20-\x21\x23-\x7e]|\\/.test(action))
             return fail('unsupported', 'unsafe SOAPAction');
         const elements = (node) => {
@@ -191,9 +192,10 @@ async function exchangeSoap(contract, input, application, options, profile) {
                 return fail(mapping.kind, mapping.rule);
             faults.set(fault.name, mapping);
         }
-        const shape = (node) => {
+        const shape = (node, encodedScope = false) => {
             const children = elements(node);
-            if (node.attributes.length || node.children.some(n => n.kind === 'text' && /[^\t\r\n ]/.test(n.value)))
+            if (node.attributes.some(a => !(encodedScope && a.name.namespace === SOAP && a.name.local === 'encodingStyle'
+                && a.value === 'http://schemas.xmlsoap.org/soap/encoding/')) || node.children.some(n => n.kind === 'text' && /[^\t\r\n ]/.test(n.value)))
                 stop('protocol', 'SOAP protocol attributes or text');
             return children;
         };
@@ -201,7 +203,7 @@ async function exchangeSoap(contract, input, application, options, profile) {
         const bodyRoot = (root, incoming = false) => {
             if (!same(root.name, { namespace: SOAP, local: 'Envelope' }))
                 stop('protocol', 'SOAP 1.1 Envelope required');
-            const children = shape(root);
+            const children = shape(root, rpc);
             if (children[0]?.name.namespace === SOAP && children[0].name.local === 'Header') {
                 if (profile.component && incoming) {
                     const assessed = assessComponentSoapHeader(children[0], check);
@@ -219,13 +221,25 @@ async function exchangeSoap(contract, input, application, options, profile) {
             }
             if (children.length !== 1 || !same(children[0].name, { namespace: SOAP, local: 'Body' }))
                 stop('protocol', 'one SOAP Body required');
-            const body = shape(children[0]);
+            const body = shape(children[0], rpc);
+            if (rpc && !body.some(n => same(n.name, { namespace: SOAP, local: 'Fault' })))
+                return children[0];
             if (body.length !== 1)
                 stop('protocol', 'one SOAP Body payload required');
             return body[0];
         };
         const wsdl = await profile.prepare(config, check);
         check();
+        // @why node-soap's RPC writer would wrap `_xml` as a parameter. This private
+        //   instance retains its selected method/transport while native bytes own RPC construction.
+        const rpcArguments = Object.freeze({});
+        if (rpc)
+            wsdl.objectToRpcXML = (name, args) => {
+                check();
+                if (name !== contract.selector.operation || args !== rpcArguments)
+                    stop('protocol', 'dependency RPC selection mismatch');
+                return Buffer.from(encoded.bytes).toString('utf8');
+            };
         // HTTP and codec byte limits bound buffering and output copies directly.
         agent = endpoint.protocol === 'https:' ? new HttpsAgent({ keepAlive: false, maxSockets: 1, rejectUnauthorized: true,
             ...(config.ca === undefined ? {} : { ca: config.ca }) }) : new Agent({ keepAlive: false, maxSockets: 1 });
@@ -290,7 +304,7 @@ async function exchangeSoap(contract, input, application, options, profile) {
         if (typeof method !== 'function')
             return fail('unsupported', 'dependency selected method unavailable');
         check();
-        await new Promise((resolve, reject) => method({ _xml: Buffer.from(encoded.bytes).toString('utf8') }, (error) => error === complete ? resolve() : reject(error), {}, { SOAPAction: `"${action}"` }));
+        await new Promise((resolve, reject) => method(rpc ? rpcArguments : { _xml: Buffer.from(encoded.bytes).toString('utf8') }, (error) => error === complete ? resolve() : reject(error), {}, { SOAPAction: `"${action}"` }));
         check();
         if (timedOut)
             return fail('transport', 'SOAP deadline exceeded');
@@ -301,19 +315,22 @@ async function exchangeSoap(contract, input, application, options, profile) {
         const observed = response;
         if (observed.encoding && observed.encoding.toLowerCase() !== 'identity')
             return fail('unsupported', 'HTTP compression');
-        const media = /^text\/xml(?:\s*;\s*charset\s*=\s*(?:"(utf-8|utf-16|utf-16le|utf-16be)"|(utf-8|utf-16|utf-16le|utf-16be)))?\s*$/i.exec(observed.contentType);
+        const media = /^text\/xml(?:\s*;\s*charset\s*=\s*(?:"(utf-8|utf-16|utf-16le|utf-16be|iso-8859-1)"|(utf-8|utf-16|utf-16le|utf-16be|iso-8859-1)))?\s*$/i.exec(observed.contentType);
         if (!media)
             return fail('protocol', 'SOAP response Content-Type');
         if (observed.status !== 200 && observed.status !== 500)
             return fail('transport', 'SOAP HTTP status');
         // Header charset is a protocol assertion, checked against actual BOM bytes.
         const charset = (media[1] ?? media[2])?.toLowerCase();
+        if (!profile.component && charset === 'iso-8859-1')
+            return fail('protocol', 'SOAP response Content-Type');
         const bom = observed.bytes[0] === 0xff && observed.bytes[1] === 0xfe ? 'utf-16le'
             : observed.bytes[0] === 0xfe && observed.bytes[1] === 0xff ? 'utf-16be' : 'utf-8';
-        if (charset && charset !== bom && !(charset === 'utf-16' && bom.startsWith('utf-16')))
+        if (!profile.component && charset && charset !== bom && !(charset === 'utf-16' && bom.startsWith('utf-16')))
             return fail('protocol', 'SOAP charset disagrees with bytes');
         let faultInfo;
         const decoded = profile.decode(contract, output, observed.bytes, { signal, limits, uri: endpoint.href,
+            ...(profile.component ? { componentResponseEncoding: { charset } } : {}),
             selectPayload: root => {
                 const payload = bodyRoot(root, true);
                 if (!same(payload.name, { namespace: SOAP, local: 'Fault' })) {

package/dist/compiler/directSourceCapsule.js

@@ -316,6 +316,8 @@ export function checkDirectSourceCompatibility(expected, contract, selection, si
 const componentVersions = Object.freeze({ ...versions, scope: 'component-soap11-utf8-graph-v1', mapping: 'component-values-v1',
     runtimePolicy: 'explicit-http-verified-https-transport-v1' });
 const scopedComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap11-utf8-graph-v2', mapping: 'component-values-and-record-scope-v1' });
+const rpcComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap11-rpc-strings-v1', mapping: 'component-rpc-string-values-v1' });
+const typedRpcComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap11-rpc-typed-latin1-v1', mapping: 'component-rpc-typed-values-v1' });
 const componentReconstructions = new WeakMap();
 function componentFailure(error, budget) {
     return Object.freeze({ ...failure(error, budget), repair: 'Regenerate matched component artifacts from explicitly authorized original WSDL and dependencies.' });
@@ -362,6 +364,17 @@ async function componentDescriptor(contract, selection, signal, responseProjecti
         if (mapping.kind !== 'component-mapping' && mapping.kind !== 'component-record-projection')
             throw new Stop(mapping.kind === 'resource-limit' || mapping.kind === 'cancelled' ? mapping.kind : 'unsupported', mapping.rule);
         mappings.push(mapping);
+        if ('parts' in mapping.root)
+            return { kind: 'rpc-typed-parts-v1', message: mapping.root.message,
+                wrapper: mapping.root.wrapper, bodyNamespace: mapping.root.bodyNamespace, encoding: contract.binding.encoding,
+                parts: mapping.root.parts.map(part => {
+                    const resolved = inspectDirectOperation(contract).context.resolve(part.type);
+                    const type = resolved.kind === 'builtin' ? resolved.name : resolved.kind === 'found' && resolved.node.identity.kind === 'global'
+                        ? resolved.node.identity.name : undefined;
+                    if (!type)
+                        throw new Stop('unsupported', 'rpc-named-type-required');
+                    return { name: part.name, type };
+                }) };
         return { element: mapping.root.element.name, message: mapping.root.message, part: mapping.root.part };
     };
     const input = make({ kind: 'input' }), output = make({ kind: 'output' });
@@ -371,6 +384,8 @@ async function componentDescriptor(contract, selection, signal, responseProjecti
     let projection = null;
     if (responseProjection) {
         const { companion } = inspectComponentRecordProjection(responseProjection, contract);
+        if ('parts' in companion.output)
+            throw new Stop('unsupported', 'record-projection-requires-document-output');
         const { context } = inspectDirectOperation(companion);
         projection = { spec: responseProjection.spec, source: { selector: companion.selector, action: companion.binding.action,
                 output: { element: companion.output.element.name, message: companion.output.message, part: companion.output.part },
@@ -412,7 +427,11 @@ export async function createComponentSourceCapsule(contract, selection, signal,
 function componentCapsule(derived, budget) {
     const { compatibility, resources, libraries, projection } = derived;
     const extended = libraries.length > 0 || projection !== null;
-    const value = { versions: extended ? scopedComponentVersions : componentVersions, resources, compatibility,
+    const rpc = 'kind' in compatibility.input && compatibility.input.kind === 'rpc-typed-parts-v1';
+    const typedRpc = rpc && compatibility.input.parts.some(part => part.type.namespace !== 'http://www.w3.org/2001/XMLSchema' || part.type.local !== 'string');
+    if (rpc && (extended || derived.applicationGroups))
+        throw new Stop('unsupported', 'rpc-artifact-extension');
+    const value = { versions: typedRpc ? typedRpcComponentVersions : rpc ? rpcComponentVersions : extended ? scopedComponentVersions : componentVersions, resources, compatibility,
         ...(extended ? { libraries, projection } : {}), ...(derived.applicationGroups ? { applicationGroups: derived.applicationGroups, applicationGroupIdentity: derived.applicationGroupIdentity } : {}) };
     return { ...value, fingerprint: hash(json(value, budget)) };
 }
@@ -470,13 +489,45 @@ function readComponent(bytes, budget, signal) {
         if (!/^[a-f0-9]{64}$/.test(parsed.applicationGroupIdentity))
             reject('application-group-identity');
     }
-    const expectedVersions = extended ? scopedComponentVersions : componentVersions;
+    const typedRpc = !!parsed.versions && typeof parsed.versions === 'object' && parsed.versions.scope === typedRpcComponentVersions.scope;
+    const rpc = typedRpc || !!parsed.versions && typeof parsed.versions === 'object' && parsed.versions.scope === rpcComponentVersions.scope;
+    if (rpc && (extended || grouped))
+        reject('rpc-artifact-extension');
+    const expectedVersions = typedRpc ? typedRpcComponentVersions : rpc ? rpcComponentVersions : extended ? scopedComponentVersions : componentVersions;
     const actual = record(parsed.versions, Object.keys(expectedVersions));
     for (const key of Object.keys(expectedVersions))
         if (actual[key] !== expectedVersions[key])
             reject('unsupported-version-mode-or-policy');
     validateComponentResources(parsed.resources, budget, signal);
-    const root = (value) => { const r = record(value, ['element', 'message', 'part']); name(r.element); name(r.message); ncname(r.part); };
+    const root = (value) => {
+        if (rpc) {
+            const r = record(value, ['kind', 'message', 'wrapper', 'bodyNamespace', 'encoding', 'parts']);
+            if (r.kind !== 'rpc-typed-parts-v1' || r.encoding !== 'http://schemas.xmlsoap.org/soap/encoding/')
+                reject('rpc-root-profile');
+            name(r.message);
+            name(r.wrapper);
+            text(r.bodyNamespace);
+            if (!Array.isArray(r.parts) || !r.parts.length)
+                return reject('rpc-parts-required');
+            const names = new Set();
+            for (const part of r.parts) {
+                check(budget, signal);
+                const p = record(part, ['name', 'type']);
+                ncname(p.name);
+                name(p.type);
+                if (names.has(p.name))
+                    reject('duplicate-rpc-part');
+                names.add(p.name);
+                if (!typedRpc && (p.type.namespace !== 'http://www.w3.org/2001/XMLSchema' || p.type.local !== 'string'))
+                    reject('rpc-part-type');
+            }
+            return;
+        }
+        const r = record(value, ['element', 'message', 'part']);
+        name(r.element);
+        name(r.message);
+        ncname(r.part);
+    };
     const selector = (value) => { const s = record(value, ['portType', 'binding', 'operation']); name(s.portType); name(s.binding); ncname(s.operation); };
     if (extended) {
         validateComponentLibraries(parsed.libraries);
@@ -520,6 +571,11 @@ function readComponent(bytes, budget, signal) {
     text(c.action);
     root(c.input);
     root(c.output);
+    if (rpc) {
+        const parts = c.input.parts;
+        if (typedRpc !== parts.some(part => part.type.namespace !== 'http://www.w3.org/2001/XMLSchema' || part.type.local !== 'string'))
+            reject('rpc-type-version');
+    }
     if (!Array.isArray(c.faults))
         return reject('faults-required');
     const names = new Set();

package/dist/compiler/directStructure.js

@@ -514,8 +514,12 @@ export function matchDirectOperation(contract, direction, payload, options = {})
                     throw new Stop('unsupported', 'unknown-fault');
                 root = selected.root;
             }
-            else
-                root = contract[ownedDirection.kind];
+            else {
+                const selected = contract[ownedDirection.kind];
+                if ('parts' in selected)
+                    throw new Stop('unsupported', 'direct-document-root-required');
+                root = selected;
+            }
             const matched = matchDirectProjection(context, root.element, payload, { ...options, flatOnly: true });
             if (matched.kind !== 'projection-match')
                 return matched;

package/dist/compiler/directStructurePlan.d.ts

@@ -1,7 +1,7 @@
 /** Single native direct slot interpretation shared by matching and value mapping. */
 import type { DirectMessageRoot } from './directOperation.js';
 import type { SemanticContext } from './semanticContext.js';
-import type { AttributeNode, ComplexTypeNode, ElementNode, NodeId, ParticleNode } from './canonicalGraph.js';
+import type { AttributeNode, ComplexTypeNode, ElementNode, GraphNode, NodeId, ParticleNode, Reference } from './canonicalGraph.js';
 import type { ExpandedName } from '../loader/orderedSyntax.js';
 import type { ProjectionScalarList } from './projectionScalar.js';
 import type { SemanticParticle, SemanticParticleView } from './particleSemanticView.js';
@@ -143,6 +143,15 @@ export declare function selectProjectionAttribute(context: SemanticContext, reco
  *   The checked-direct preview adapter below retains its flat-only grammar.
  */
 export declare function planDirectProjection(context: SemanticContext, root: ElementNode, check: () => void, unsupported: (detail?: DirectProjectionUnavailable) => never): DirectProjectionPlan;
+/** Plan a source-owned type using native scalar, content and particle owners.
+ * @param context Native source context.
+ * @param owner Exact source graph node owning the type reference.
+ * @param reference Selected source type.
+ * @param check Cooperative checkpoint.
+ * @param unsupported Explicit refusal callback.
+ * @returns The same native projection used by document elements, without element facts.
+ */
+export declare function planProjectionType(context: SemanticContext, owner: GraphNode, reference: Reference, check: () => void, unsupported: (detail?: DirectProjectionUnavailable) => never): DirectProjectionPlan;
 /** Adapt the native projection to the supported flat preview without widening admission. */
 export declare function planDirectRoot(context: SemanticContext, root: DirectMessageRoot, check: () => void, unsupported: () => never): DirectRootPlan;
 /** Flat-only projection adapter; its input is derived data, never native admission. */