@techspokes/typescript-wsdl-client 1.3.0 → 1.4.0

package/dist/client/checkedDirectRuntime.js

@@ -1,6 +1,6 @@
 import { types } from 'node:util';
-import { directClientRuntime, componentClientRuntime, componentSoap12ClientRuntime } from './directClientRuntime.js';
-import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_REPAIR, COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
+import { directClientRuntime, componentClientRuntime, componentSoap11ClientRuntime, componentSoap12ClientRuntime } from './directClientRuntime.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_REPAIR, COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION, COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
 function dataOptions(options, allowed) {
     return !!options && typeof options === 'object' && !types.isProxy(options)
         && [null, Object.prototype].includes(Object.getPrototypeOf(options))
@@ -41,20 +41,28 @@ export const checkedComponentRuntimeV1 = Object.freeze({
         return componentClientRuntime.execute(expectedBase64, input, options);
     },
 });
+function checkedProtocolRuntime(runtime) {
+    return Object.freeze({
+        version: runtime.version,
+        async execute(expectedBase64, input, options, version) {
+            if (version !== runtime.version)
+                return Object.freeze({ kind: 'incompatible-artifact',
+                    rule: 'generated-runtime-version', repair: COMPONENT_CLIENT_RUNTIME_REPAIR, usage: Object.freeze({ nodes: 0, work: 0 }) });
+            if (!dataOptions(options, ['localSource', 'fileRoots', 'capsule', 'soap', 'sourceResources', 'sourceOrigins', 'sourceUri', 'namespaceLocations', 'standardLibraries', 'recordSources'])) {
+                return Object.freeze({ kind: 'unsupported', rule: 'data-only checked component options required', usage: Object.freeze({ nodes: 0, work: 0 }) });
+            }
+            return runtime.execute(expectedBase64, input, options);
+        },
+    });
+}
 /** Additive SOAP 1.2 binding permits protocol faults without declared application detail.
  * @since 1.3.0
  * @remarks Source reconstruction, endpoint restrictions and native validation use the shared component runtime.
  * @returns Native component values, SOAP 1.2 protocol faults or explicit refusal; no full-profile admission.
  */
-export const checkedComponentRuntimeV2 = Object.freeze({
-    version: COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION,
-    async execute(expectedBase64, input, options, version) {
-        if (version !== COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION)
-            return Object.freeze({ kind: 'incompatible-artifact',
-                rule: 'generated-runtime-version', repair: COMPONENT_CLIENT_RUNTIME_REPAIR, usage: Object.freeze({ nodes: 0, work: 0 }) });
-        if (!dataOptions(options, ['localSource', 'fileRoots', 'capsule', 'soap', 'sourceResources', 'sourceOrigins', 'sourceUri', 'namespaceLocations', 'standardLibraries', 'recordSources'])) {
-            return Object.freeze({ kind: 'unsupported', rule: 'data-only checked component options required', usage: Object.freeze({ nodes: 0, work: 0 }) });
-        }
-        return componentSoap12ClientRuntime.execute(expectedBase64, input, options);
-    },
-});
+export const checkedComponentRuntimeV2 = checkedProtocolRuntime(componentSoap12ClientRuntime);
+/** SOAP 1.1 binding for generated clients that distinguish protocol faults from declared detail values.
+ * @since 1.4.0
+ * @returns Native-validated values, SOAP 1.1 protocol faults with their original bytes, or explicit refusal.
+ */
+export const checkedComponentRuntimeV3 = checkedProtocolRuntime(componentSoap11ClientRuntime);

package/dist/client/directClientRuntime.d.ts

@@ -1,6 +1,6 @@
 import type { SemanticBudgetLimits, ResolverUsage } from '../compiler/semanticBudget.js';
 import type { DirectCapsuleFailure } from '../compiler/directSourceCapsule.js';
-import type { DirectSoapOptions, ComponentSoapOptions, DirectSoapFailure, ComponentProtocolFault, DeclaredSoapFault } from '../compiler/directSoap.js';
+import type { DirectSoapOptions, ComponentSoapOptions, DirectSoapFailure, ComponentProtocolFault, DeclaredSoapFault, Soap11FaultMetadata, Soap12FaultMetadata } from '../compiler/directSoap.js';
 import type { DirectOperationSelector } from '../compiler/directOperation.js';
 import type { DirectApplicationValue } from '../compiler/directValues.js';
 import { DIRECT_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
@@ -68,9 +68,9 @@ export interface DirectClientRuntime {
 /** Component-only protocol faults retain raw bytes without claiming an application value.
  * @since 1.3.0
  */
-export type ComponentClientResult = Exclude<DirectClientResult, {
+export type ComponentClientResult<F extends Soap11FaultMetadata | Soap12FaultMetadata = Soap12FaultMetadata> = Exclude<DirectClientResult, {
     kind: 'soap-fault';
-}> | ComponentProtocolFault | Readonly<Omit<Extract<DirectClientResult, {
+}> | ComponentProtocolFault<F> | Readonly<Omit<Extract<DirectClientResult, {
     kind: 'soap-fault';
 }>, 'fault'> & {
     fault: Omit<DeclaredSoapFault, 'codeNode'>;
@@ -89,3 +89,10 @@ export declare const componentSoap12ClientRuntime: Readonly<{
     version: "checked-component-soap12-runtime-v1";
     execute: (expectedBase64: string, input: unknown, options: ComponentClientOptions) => Promise<ComponentClientResult>;
 }>;
+/** SOAP 1.1 protocol faults require a generated client that can represent a missing application value.
+ * @since 1.4.0
+ */
+export declare const componentSoap11ClientRuntime: Readonly<{
+    version: "checked-component-soap11-runtime-v1";
+    execute: (expectedBase64: string, input: unknown, options: ComponentClientOptions) => Promise<ComponentClientResult<Soap11FaultMetadata>>;
+}>;

package/dist/client/directClientRuntime.js

@@ -6,7 +6,7 @@ import { types } from 'node:util';
 import { createApplicationBudget } from '../compiler/semanticBudget.js';
 import { reconstructDirectSourceCapsuleInRequest, reconstructComponentSourceCapsuleInRequest, checkDirectSourceCompatibility, DIRECT_CAPSULE_LIMITS } from '../compiler/directSourceCapsule.js';
 import { exchangeDirectSoap, exchangeComponentSoap, directSoapOptionsShape } from '../compiler/directSoap.js';
-import { DIRECT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION, COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
 import { prepareSchemaSnapshotFiles } from '../loader/schemaInput.js';
 import { SchemaLoadingError } from '../loader/orderedSyntax.js';
 /** The generated literal is the expected artifact; caller bytes never choose its static contract. */
@@ -24,9 +24,16 @@ export const componentClientRuntime = Object.freeze({
  */
 export const componentSoap12ClientRuntime = Object.freeze({
     version: COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION,
-    execute: (expectedBase64, input, options) => executeClient(expectedBase64, input, options, true, true),
+    execute: (expectedBase64, input, options) => executeClient(expectedBase64, input, options, true, '1.2'),
 });
-async function executeClient(expectedBase64, input, options, component, allowSoap12 = false) {
+/** SOAP 1.1 protocol faults require a generated client that can represent a missing application value.
+ * @since 1.4.0
+ */
+export const componentSoap11ClientRuntime = Object.freeze({
+    version: COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION,
+    execute: (expectedBase64, input, options) => executeClient(expectedBase64, input, options, true, '1.1'),
+});
+async function executeClient(expectedBase64, input, options, component, protocol) {
     // Constant-sized entry introspection precedes budget configuration and all reads.
     const entryFailure = () => ({ kind: 'unsupported', rule: 'data-only client options required', usage: { nodes: 0, work: 0 } });
     if (!options || typeof options !== 'object' || types.isProxy(options)
@@ -128,13 +135,12 @@ async function executeClient(expectedBase64, input, options, component, allowSoa
                 standardLibraries: sources.standards, recordSources: sources.records }, budget);
             if (fresh.kind !== 'reconstructed-component')
                 return fresh;
-            if (fresh.contract.binding.version === '1.2' && !allowSoap12)
+            if (fresh.contract.binding.version === '1.2' && protocol !== '1.2')
                 return fail('incompatible-artifact', 'SOAP 1.2 runtime binding required');
             if (fresh.selection.port !== options.soap.port || fresh.selection.service.namespace !== options.soap.service.namespace
                 || fresh.selection.service.local !== options.soap.service.local)
                 return fail('incompatible-artifact', 'explicit source selection mismatch');
-            result = fresh.responseProjection ? await exchangeComponentSoap(fresh.contract, fresh.mappings[0], input, supplied.soap, fresh.responseProjection)
-                : await exchangeComponentSoap(fresh.contract, fresh.mappings[0], input, supplied.soap);
+            result = await exchangeComponentSoap(fresh.contract, fresh.mappings[0], input, supplied.soap, fresh.responseProjection, protocol === '1.1');
         }
         else {
             const fresh = await reconstructDirectSourceCapsuleInRequest(bytes, options.localSource, { policy: { fileRoots: options.fileRoots }, limits: options.budget, signal: options.soap.signal }, budget);
@@ -148,8 +154,8 @@ async function executeClient(expectedBase64, input, options, component, allowSoa
             result = await exchangeDirectSoap(fresh.contract, fresh.mappings[0], input, options.soap);
         }
         if (!('decoded' in result)) {
-            if (result.kind === 'soap-fault' && !allowSoap12)
-                return fail('incompatible-artifact', 'SOAP 1.2 runtime binding required');
+            if (result.kind === 'soap-fault' && result.fault.version !== protocol)
+                throw new TypeError('Protocol fault requires its generated runtime binding');
             return result;
         }
         if (options.soap.signal?.aborted)

package/dist/client/directClientVersion.d.ts

@@ -5,4 +5,6 @@ export declare const DIRECT_CLIENT_RUNTIME_REPAIR = "Regenerate matched direct c
 export declare const COMPONENT_CLIENT_RUNTIME_VERSION: "checked-component-runtime-v2";
 /** SOAP 1.2 can return protocol faults without declared application values. */
 export declare const COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION: "checked-component-soap12-runtime-v1";
+/** SOAP 1.1 component clients with value-less protocol faults use their own injection contract. */
+export declare const COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION: "checked-component-soap11-runtime-v1";
 export declare const COMPONENT_CLIENT_RUNTIME_REPAIR = "Regenerate matched component client and source artifacts with the installed runtime.";

package/dist/client/directClientVersion.js

@@ -5,4 +5,6 @@ export const DIRECT_CLIENT_RUNTIME_REPAIR = 'Regenerate matched direct client an
 export const COMPONENT_CLIENT_RUNTIME_VERSION = 'checked-component-runtime-v2';
 /** SOAP 1.2 can return protocol faults without declared application values. */
 export const COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION = 'checked-component-soap12-runtime-v1';
+/** SOAP 1.1 component clients with value-less protocol faults use their own injection contract. */
+export const COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION = 'checked-component-soap11-runtime-v1';
 export const COMPONENT_CLIENT_RUNTIME_REPAIR = 'Regenerate matched component client and source artifacts with the installed runtime.';

package/dist/client/generateDirectClient.js

@@ -1,5 +1,5 @@
 import { directLimit } from '../compiler/directExecutionPolicy.js';
-import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR, COMPONENT_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_REPAIR, COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR, COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION, COMPONENT_CLIENT_RUNTIME_REPAIR, COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION } from './directClientVersion.js';
 /** Native-plan generator consumed by the opt-in checked pipeline. */
 import { checkSemanticBudget } from '../compiler/semanticBudget.js';
 import { writeFileSync, mkdirSync } from 'node:fs';
@@ -171,9 +171,9 @@ export async function generateComponentClient(expected, signal) {
             ...faults.flatMap(({ shape }, index) => [...shape.declarations, `export type Fault_${index} = ${shape.type};`])
         ];
         const soap12 = expected.contract.binding.version === '1.2';
-        const runtimeVersion = soap12 ? COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION : COMPONENT_CLIENT_RUNTIME_VERSION;
+        const runtimeVersion = soap12 ? COMPONENT_SOAP12_CLIENT_RUNTIME_VERSION : COMPONENT_SOAP11_CLIENT_RUNTIME_VERSION;
         const lines = [
-            `// Checked component client; inject ${soap12 ? 'checkedComponentRuntimeV2' : 'checkedComponentRuntimeV1'} from the package root.`,
+            `// Checked component client; inject ${soap12 ? 'checkedComponentRuntimeV2' : 'checkedComponentRuntimeV3'} from the package root.`,
             '// Scalar facets, ordered occurrence correlation and wildcard membership remain native runtime duties.',
             ...declarations,
             'export interface Usage {readonly nodes: number; readonly work: number}',
@@ -193,9 +193,9 @@ export async function generateComponentClient(expected, signal) {
             '}',
             'export interface Failure {readonly kind: "incompatible-artifact" | "unsupported" | "missing-authority" | "resource-limit" | "cancelled" | "inconclusive" | "invalid-schema" | "scalar-invalid" | "value-invalid" | "xml-invalid" | "mismatch" | "transport" | "protocol";',
             '  readonly rule: string; readonly repair?: string; readonly phase?: "input" | "response"; readonly usage: Usage}',
-            `export interface NativeSuccess {readonly kind: "soap-response" | "soap-fault"; readonly value${soap12 ? '?' : ''}: unknown; readonly admitted: false;`,
+            'export interface NativeSuccess {readonly kind: "soap-response" | "soap-fault"; readonly value?: unknown; readonly admitted: false;',
             '  readonly status: number; readonly usage: Usage; readonly responseBytes: Uint8Array;',
-            `  readonly fault?: {readonly name${soap12 ? '?' : ''}: string; readonly code: Name; readonly string: string; readonly actor?: string}}`,
+            '  readonly fault?: {readonly name?: string; readonly code: Name; readonly string: string; readonly actor?: string}}',
             `export interface Runtime {readonly version: ${literal(runtimeVersion)}; execute(expectedBase64: string, input: unknown, options: Options, version: ${literal(runtimeVersion)}): Promise<Failure | NativeSuccess>}`,
             'type Common = {readonly admitted: false; readonly status: number; readonly usage: Usage; readonly responseBytes: Uint8Array};',
             'export type Result = Failure | (Common & {readonly kind: "soap-response"; readonly value: Response})',
@@ -205,8 +205,8 @@ export async function generateComponentClient(expected, signal) {
                 return soap12 ? `  | (Common & {readonly kind: "soap-fault"; readonly value: Fault_${index}; readonly fault: Soap12Fault & {readonly name: ${literal(mapping.direction.name)}}})`
                     : `  | (Common & {readonly kind: "soap-fault"; readonly value: Fault_${index}; readonly fault: {readonly name: ${literal(mapping.direction.name)}; readonly code: Name; readonly string: string; readonly actor?: string}})`;
             }),
-            ...(soap12 ? ['  | (Common & {readonly kind: "soap-fault"; readonly value?: never; readonly fault: Soap12Fault & {readonly name?: never}})']
-                : faults.length ? [] : ['  | (Common & {readonly kind: "soap-fault"; readonly value: never; readonly fault: {readonly name: never; readonly code: Name; readonly string: string; readonly actor?: string}})']),
+            soap12 ? '  | (Common & {readonly kind: "soap-fault"; readonly value?: never; readonly fault: Soap12Fault & {readonly name?: never}})'
+                : '  | (Common & {readonly kind: "soap-fault"; readonly value?: never; readonly fault: {readonly version: "1.1"; readonly name?: never; readonly code: Name; readonly string: string; readonly actor?: string}})',
             ';',
             `export const expectedCapsuleBase64 = ${literal(Buffer.from(capsule.bytes).toString('base64'))};`,
             `export const selection = ${literal(JSON.stringify({ selector: expected.contract.selector, ...expected.selection }))};`,

package/dist/compiler/componentRecordProjection.d.ts

@@ -57,6 +57,7 @@ export interface ComponentRecordDecodedXml {
 type Leaf = Readonly<{
     kind: 'standard';
     declaration: StandardSchemaElementDeclaration;
+    optional: boolean;
 } | {
     kind: 'boundary';
     namespace: NamespaceConstraint;

package/dist/compiler/componentRecordProjection.js

@@ -160,7 +160,9 @@ export function createComponentRecordProjection(outer, companion, supplied, opti
             while (pending.length) {
                 check();
                 const particle = pending.pop();
-                if (particle.occurs.min !== '1' || particle.occurs.max !== '1')
+                // @why Only metadata may be absent, and only when the authenticated source declares it optional.
+                if (particle.occurs.max !== '1' || (particle.occurs.min !== '1'
+                    && !(particle.standardElement && particle.occurs.min === '0')))
                     stop('record-wrapper-unit-occurrence');
                 if (particle.kind === 'sequence')
                     for (let index = particle.children.length - 1; index >= 0; index--) {
@@ -168,7 +170,7 @@ export function createComponentRecordProjection(outer, companion, supplied, opti
                         pending.push(particle.children[index]);
                     }
                 else if (particle.standardElement)
-                    leaves.push(Object.freeze({ kind: 'standard', declaration: particle.standardElement }));
+                    leaves.push(Object.freeze({ kind: 'standard', declaration: particle.standardElement, optional: particle.occurs.min === '0' }));
                 else if (particle.kind === 'any' && particle.wildcard?.processContents === 'strict') {
                     if (++boundaries > 1 || !namespaceAllows(particle.wildcard.namespace, spec.payloadPath[0].namespace, budget.chargeWork))
                         stop('record-wrapper-wildcard-boundary');
@@ -266,12 +268,19 @@ export function decodeComponentRecordXml(outer, projection, bytes, options = {})
             if (wrapper.attributes.length || wrapper.children.some(node => node.kind === 'text' && /[^\t\r\n ]/.test(node.value)))
                 throw new ScopeStop('mismatch', 'record-wrapper-attributes-or-text');
             const children = syntaxElements(wrapper);
-            if (children.length !== owned.leaves.length)
+            const required = owned.leaves.filter(leaf => leaf.kind === 'boundary' || !leaf.optional).length;
+            if (children.length < required || children.length > owned.leaves.length)
                 throw new ScopeStop('mismatch', 'record-wrapper-child-count');
             let payload;
+            let cursor = 0;
             for (let index = 0; index < owned.leaves.length; index++) {
                 check();
-                const leaf = owned.leaves[index], child = children[index];
+                const leaf = owned.leaves[index], child = children[cursor];
+                if (leaf.kind === 'standard' && leaf.optional && (!child || !same(child.name, leaf.declaration.name)))
+                    continue;
+                if (!child)
+                    throw new ScopeStop('mismatch', 'record-wrapper-child-count');
+                cursor++;
                 if (leaf.kind === 'standard') {
                     if (!same(child.name, leaf.declaration.name))
                         throw new ScopeStop('mismatch', 'record-wrapper-standard-order');
@@ -287,6 +296,8 @@ export function decodeComponentRecordXml(outer, projection, bytes, options = {})
                     payload = child;
                 }
             }
+            if (cursor !== children.length)
+                throw new ScopeStop('mismatch', 'record-wrapper-child-count');
             if (!payload)
                 throw new TypeError('Native record boundary unavailable');
             const decoded = assessObservedComponentPayload(owned.companion, owned.mapping, observation, payload, options);

package/dist/compiler/directCodec.js

@@ -3,6 +3,7 @@ import { directDataOwnership, directLimit } from './directExecutionPolicy.js';
 import { checkSemanticBudget } from './semanticBudget.js';
 import { DataOwnershipLimitError } from './dataOwnership.js';
 import { types } from 'node:util';
+import { xmlByteLength, snapshotXmlBytes } from '../util/xmlBytes.js';
 import { inspectDirectOperation, isRpcMessageRoot } from './directOperation.js';
 import { inspectDirectValueMapping, expandDirectValue, assessDirectScalars, inspectComponentValueMapping, expandProjectionValue, assessProjectionScalars } from './directValues.js';
 import { matchDirectOperation, matchDirectProjection } from './directStructure.js';
@@ -262,20 +263,11 @@ 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, 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
-    // iterator getters. Shared backing stores are outside the data-only contract.
-    const typed = Object.getPrototypeOf(Uint8Array.prototype);
-    const length = Object.getOwnPropertyDescriptor(typed, 'byteLength').get.call(bytes);
-    const backing = Object.getOwnPropertyDescriptor(typed, 'buffer').get.call(bytes);
-    if (types.isSharedArrayBuffer(backing))
-        throw new TypeError('Shared XML bytes are unsupported');
+    const length = xmlByteLength(bytes);
     if (length > limits.maxBytes)
         throw new Stop('resource-limit', 'XML byte limit');
     check();
-    const input = new Uint8Array(length);
-    Uint8Array.prototype.set.call(input, bytes);
+    const input = snapshotXmlBytes(bytes);
     const uri = sourceUri ?? 'urn:typescript-wsdl-client:observed-direct-xml';
     if (typeof uri !== 'string')
         throw new TypeError('XML source URI must be a string');

package/dist/compiler/directSoap.d.ts

@@ -1,6 +1,6 @@
 import type { DirectOperationContract } from './directOperation.js';
 import type { DirectCodecFailure, DirectDecodedXml, ComponentDecodedXml, DirectXmlLimits } from './directCodec.js';
-import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
+import type { ExpandedName, SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
 import type { ResolverUsage } from './semanticBudget.js';
 import type { ComponentRecordProjection, ComponentRecordDecodedXml } from './componentRecordProjection.js';
 export interface DirectSoapOptions {
@@ -20,6 +20,9 @@ export interface DirectSoapFailure {
     readonly rule: string;
     readonly usage: ResolverUsage;
     readonly phase?: 'input' | 'response';
+    readonly source?: SyntaxSource;
+    readonly schemaPath?: string;
+    readonly payloadPath?: string;
 }
 /** Version-specific protocol metadata; application detail remains owned by native mappings.
  * @since 1.3.0
@@ -36,6 +39,16 @@ export interface Soap12FaultMetadata {
     readonly node?: string;
     readonly role?: string;
 }
+/** SOAP 1.1 protocol fields retained when the selected operation supplies no matching detail.
+ * @since 1.4.0
+ */
+export interface Soap11FaultMetadata {
+    readonly version: '1.1';
+    readonly code: ExpandedName;
+    readonly string: string;
+    readonly actor?: string;
+}
+type ProtocolFaultMetadata = Soap11FaultMetadata | Soap12FaultMetadata;
 export type DeclaredSoapFault = Readonly<{
     name: string;
     code: ExpandedName;
@@ -43,14 +56,14 @@ export type DeclaredSoapFault = Readonly<{
     string: string;
     actor?: string;
 }> & Partial<Soap12FaultMetadata>;
-/** A valid SOAP 1.2 fault without a uniquely declared application detail.
+/** A valid protocol fault without an application detail mapped by the selected operation.
  * @since 1.3.0
  * @constraints Unassessed detail remains only in responseBytes; no native value receipt is issued.
  */
-export interface ComponentProtocolFault {
+export interface ComponentProtocolFault<F extends ProtocolFaultMetadata = ProtocolFaultMetadata> {
     readonly kind: 'soap-fault';
     readonly admitted: false;
-    readonly fault: Soap12FaultMetadata;
+    readonly fault: F;
     readonly responseBytes: Uint8Array;
     readonly status: number;
     readonly usage: ResolverUsage;
@@ -92,5 +105,37 @@ export declare function exchangeDirectSoap(contract: DirectOperationContract, in
  * @throws TypeError For foreign native handles. Invalid explicit timer/XML capacities throw RangeError.
  */
 export declare function exchangeComponentSoap(contract: DirectOperationContract, inputMapping: unknown, application: unknown, options: ComponentSoapOptions): Promise<ComponentSoapResult>;
-export declare function exchangeComponentSoap(contract: DirectOperationContract, inputMapping: unknown, application: unknown, options: ComponentSoapOptions, responseProjection: ComponentRecordProjection): Promise<ComponentRecordSoapResult>;
+export declare function exchangeComponentSoap(contract: DirectOperationContract, inputMapping: unknown, application: unknown, options: ComponentSoapOptions, responseProjection: ComponentRecordProjection | undefined, soap11ProtocolFaults?: boolean): Promise<ComponentRecordSoapResult>;
+/** Actual HTTP entity metadata; omission leaves HTTP status and media duties unassessed.
+ * @since Unreleased
+ */
+export interface ObservedSoapResponseMetadata {
+    readonly status: number;
+    readonly contentType: string;
+    readonly contentEncoding?: string;
+}
+export type ComponentSoapResponseAssessment = DirectSoapFailure | Readonly<{
+    kind: 'soap-response' | 'soap-fault';
+    admitted: false;
+    decoded?: ComponentDecodedXml | ComponentRecordDecodedXml;
+    fault?: DeclaredSoapFault | ProtocolFaultMetadata;
+    ignoredHeaders?: readonly ExpandedName[];
+    usage: ResolverUsage;
+}>;
+/** Assess caller-observed response bytes through the same protocol and native decoder used by real exchanges.
+ * @param contract Authenticated selected component operation.
+ * @param inputMapping Exact operation input mapping, used only to derive response/fault mappings.
+ * @param bytes Actual observed SOAP entity bytes; no request or transport is constructed.
+ * @param options XML controls, optional actual HTTP metadata and exact response projection.
+ * @returns Native response/fault assessment or semantic failure; HTTP remains unassessed when metadata is absent.
+ * @throws TypeError For foreign native handles; RangeError for invalid explicit XML limits.
+ * @constraints This response-only helper performs no transport, endpoint authorization or request-value assessment.
+ */
+export declare function inspectComponentSoapResponse(contract: DirectOperationContract, inputMapping: unknown, bytes: Uint8Array, options?: Readonly<{
+    signal?: AbortSignal;
+    limits?: DirectXmlLimits;
+    uri?: string;
+    responseMetadata?: ObservedSoapResponseMetadata;
+    responseProjection?: ComponentRecordProjection;
+}>): ComponentSoapResponseAssessment;
 export {};