@techspokes/typescript-wsdl-client 1.3.0 → 1.4.0

package/README.md

@@ -9,6 +9,10 @@ Turn legacy WSDL/SOAP services into typed TypeScript clients and optional REST A
 
 Created from production integration work at [TechSpokes](https://www.techspokes.com); built for teams modernizing real enterprise SOAP integrations.
 
+## Upgrading to 1.4.0
+
+Version 1.4.0 adds explicit JSON source corrections, offline SOAP response inspection, and checked SOAP 1.1 protocol faults without invented application values. Existing runtime bindings remain available; regenerate matched SOAP 1.1 artifacts to adopt the additive V3 binding. Read the [1.3.x migration guidance](docs/migration.md#from-13x-to-140).
+
 ## Upgrading to 1.3.0
 
 Version 1.3.0 adds opt-in checked SOAP 1.2 document/literal execution through the existing adapter. Existing SOAP 1.1 and direct-runtime bindings retain their contracts. SOAP 1.2 clients use an additive runtime handshake; regenerate matched artifacts when adopting that binding. Read the [1.2.x migration guidance](docs/migration.md#from-12x-to-130) for adoption and evidence limits.
@@ -254,8 +258,10 @@ See [CLI Reference](docs/cli-reference.md) for all flags and examples.
 | [Agent Skill Artifact](docs/agent-skill.md) | Release ZIP for consumer-project AI agents |
 | [Version Migration](docs/migration.md) | Upgrading between package versions |
 | [1.2.0 Release Notes](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/docs/releases/v1.2.0.md) | Composition, consumer compatibility and bounded RPC qualification |
+| [1.4.0 Release Notes](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/docs/releases/v1.4.0.md) | Contract corrections, offline inspection and SOAP 1.1 protocol faults |
 | [1.3.0 Release Notes](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/docs/releases/v1.3.0.md) | Checked SOAP 1.2 execution and preserved SOAP 1.1 compatibility |
 | [XML/JSON Mapping Contract](docs/mapping-contract.md) | Checked keyed, namespace, nil and group representations |
+| [Protocol Fault Compatibility](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/docs/decisions/005-checked-protocol-fault-compatibility.md) | Runtime adoption and complete-source inspection decisions |
 | [Product Corpus](docs/corpus.md) | Representative public inputs and their executable evidence |
 
 ### Contributing
@@ -328,6 +334,8 @@ Built and maintained by [TechSpokes](https://www.techspokes.com). Created by [Se
 
 ## Schema assessment diagnostics
 
+For saved SOAP responses, use `wsdl-tsc inspect-response` to assess a checked contract offline and optionally produce a source correction draft. XML-only reports leave HTTP checks unassessed. Checked generation accepts consumer-owned external JSON corrections through `sourceCorrectionsFile`; generated runtime artifacts use the effective metadata without needing the recipe. See [source corrections and response inspection](docs/checked-gateway.md#consumer-owned-source-corrections) for configuration, limits and the update workflow.
+
 `assess` is an additive diagnostic command. It writes a versioned JSON report without generating artifacts or dispatching SOAP.
 
 ```bash

package/dist/checkedPipeline.d.ts

@@ -2,12 +2,14 @@ import type { PipelineOptions } from './pipeline.js';
 import type { DirectOperationSelector } from './compiler/directOperation.js';
 import type { ReconstructedComponentSource } from './compiler/directSourceCapsule.js';
 import type { GeneratedComponentClient } from './client/generateDirectClient.js';
-import type { SchemaInput } from './loader/schemaInput.js';
+import type { SchemaInput, SchemaInputOptions } from './loader/schemaInput.js';
+import { prepareCorrectedSourceInputs } from './compiler/sourceCorrections.js';
 import type { ComponentRecordProjectionSpec, ComponentRecordProjectionAssociation, ComponentRecordProjection } from './compiler/componentRecordProjection.js';
 import type { ApplicationGroupsOptions, ApplicationGroupTarget, ApplicationGroupRecord } from './compiler/applicationGroups.js';
 /** Explicit service operations and independently authorized snapshots for component generation. */
 export interface CheckedComponentOptions {
     readonly applicationGroups?: ApplicationGroupsOptions;
+    readonly sourceCorrectionsFile?: string;
     readonly service: {
         readonly namespace: string;
         readonly local: string;
@@ -85,6 +87,57 @@ export declare function parseCheckedComponentOptions(value: unknown): CheckedCom
  * @throws TypeError For malformed or unsupported controls.
  */
 export declare function parseCheckedComponentChoices(value: unknown): Partial<CheckedComponentOptions>;
+export interface PreparedCheckedSourceInputs {
+    readonly main: SchemaInput;
+    readonly companions: ReadonlyMap<string, SchemaInput>;
+    readonly provenance: Awaited<ReturnType<typeof prepareCorrectedSourceInputs>>['provenance'] & {
+        readonly recipeFile: {
+            readonly digest: string;
+        };
+    };
+}
+/**
+ * Acquire the complete authorized original source closure for correction and diagnostic inventory.
+ * @param source Main source location, retaining its configured logical URI.
+ * @param config Explicit loading scope and companion sources.
+ * @param acquiredMain Already acquired main closure, reused without another source read.
+ * @returns Original main and companion inputs with their shared loading policy and work accounting.
+ * @throws For unavailable or unauthorized sources and exhausted source limits.
+ * @constraints Acquisition does not qualify sources or grant response authority.
+ */
+export declare function acquireCheckedSourceInputs(source: string, config: Pick<CheckedComponentOptions, 'fileRoots' | 'sourceOrigins' | 'sourceResources'> & Partial<CheckedComponentOptions>, acquiredMain?: SchemaInput): Promise<{
+    main: Readonly<{
+        root: import("./loader/orderedSyntax.js").SyntaxDocument;
+        documents: readonly import("./loader/orderedSyntax.js").SyntaxDocument[];
+        schemas: readonly import("./loader/schemaInput.js").SchemaInterpretation[];
+        resources: readonly import("./loader/schemaResources.js").ResourceMetadata[];
+        resourceAliases: ReadonlyMap<string, string>;
+        edges: readonly import("./loader/schemaInput.js").ResolutionEdge[];
+        limits: import("./loader/schemaResources.js").LoadingLimits;
+        metrics: Readonly<{
+            resources: number;
+            totalBytes: number;
+            ioMs: number;
+        }>;
+    }>;
+    companions: Map<string, Readonly<{
+        root: import("./loader/orderedSyntax.js").SyntaxDocument;
+        documents: readonly import("./loader/orderedSyntax.js").SyntaxDocument[];
+        schemas: readonly import("./loader/schemaInput.js").SchemaInterpretation[];
+        resources: readonly import("./loader/schemaResources.js").ResourceMetadata[];
+        resourceAliases: ReadonlyMap<string, string>;
+        edges: readonly import("./loader/schemaInput.js").ResolutionEdge[];
+        limits: import("./loader/schemaResources.js").LoadingLimits;
+        metrics: Readonly<{
+            resources: number;
+            totalBytes: number;
+            ioMs: number;
+        }>;
+    }>>;
+    loading: SchemaInputOptions;
+}>;
+/** Correct and reload the complete authorized project closure without mutating original sources. */
+export declare function prepareCheckedSourceInputs(source: string, config: Pick<CheckedComponentOptions, 'fileRoots' | 'sourceOrigins' | 'sourceResources'> & Partial<CheckedComponentOptions>, acquiredMain?: SchemaInput): Promise<PreparedCheckedSourceInputs>;
 /**
  * Generate the bounded preview without creating a flattened catalog authority.
  * @param opts Public pipeline options with the checked model explicitly selected.
@@ -104,7 +157,25 @@ export declare function prepareComponentStages(wsdl: string, config: CheckedComp
     gatewayDir: string;
     openapiFile: string;
     basePath: string;
-}): Promise<{
+}, sourcePreparation?: PreparedCheckedSourceInputs): Promise<{
+    sourceCorrections?: (Readonly<{
+        version: 1;
+        canonicalRecipeDigest: string;
+        resources: readonly Readonly<{
+            uri: string;
+            originalDigest: string;
+            effectiveDigest: string;
+            changed: boolean;
+        }>[];
+        corrections: readonly Readonly<{
+            kind: "set-occurs" | "set-wildcard-namespaces" | "insert-element";
+            target: import("./compiler/sourceCorrections.js").SourceCorrectionSelector;
+        }>[];
+    }> & {
+        readonly recipeFile: {
+            readonly digest: string;
+        };
+    }) | undefined;
     expected: ReconstructedComponentSource[];
     projections: Map<string, ComponentRecordProjection>;
     namespaces: Map<string, string>;

package/dist/checkedPipeline.js

@@ -9,12 +9,14 @@ import { fileURLToPath } from 'node:url';
 import { pathToFileURL } from 'node:url';
 import { types } from 'node:util';
 import { createHash } from 'node:crypto';
+import { constants as bufferConstants } from 'node:buffer';
 import { resolveResourceUri } from './loader/schemaResources.js';
 import { selectComponentOperations, inspectDirectOperation } from './compiler/directOperation.js';
 import { prepareComponentSourceForOperation } from './compiler/directSourceCapsule.js';
 import { inspectComponentSourceService } from './compiler/directSourceCapsule.js';
 import { generateComponentClient, writeComponentServiceClient } from './client/generateDirectClient.js';
-import { copyOriginalSchemaResource, prepareSchemaSnapshotFiles } from './loader/schemaInput.js';
+import { copyOriginalSchemaResource, loadSemanticSchemaInput, prepareSchemaSnapshotFiles } from './loader/schemaInput.js';
+import { prepareCorrectedSourceInputs, SourceCorrectionError } from './compiler/sourceCorrections.js';
 import { createApplicationBudget } from './compiler/semanticBudget.js';
 import { directLoadingLimits } from './compiler/directExecutionPolicy.js';
 import { generateComponentServiceGateway } from './gateway/generateCheckedGateway.js';
@@ -86,7 +88,7 @@ function parseComponentOptions(value, resolved) {
             throw new TypeError('Known unique standard libraries required');
         return ids.sort();
     };
-    const data = record(value, ['selectors', 'service', 'port', 'fileRoots', 'sourceResources', 'sourceOrigins', 'sourceUri', 'namespaceLocations', 'basePath', 'signal', 'standardLibraries', 'recordProjections', 'applicationGroups'], resolved ? ['selectors', 'service', 'port', 'fileRoots', 'sourceResources', 'sourceOrigins'] : []);
+    const data = record(value, ['selectors', 'service', 'port', 'fileRoots', 'sourceResources', 'sourceOrigins', 'sourceUri', 'namespaceLocations', 'basePath', 'signal', 'standardLibraries', 'recordProjections', 'applicationGroups', 'sourceCorrectionsFile'], resolved ? ['selectors', 'service', 'port', 'fileRoots', 'sourceResources', 'sourceOrigins'] : []);
     if (['selectors', 'service', 'port', 'fileRoots', 'sourceResources', 'sourceOrigins'].some(key => Object.hasOwn(data, key) && data[key] === undefined))
         throw new TypeError('Explicit component choices must not be undefined');
     const selectors = data.selectors === undefined ? undefined : array(data.selectors).map(selector);
@@ -142,6 +144,7 @@ function parseComponentOptions(value, resolved) {
     if (data.signal !== undefined && !(data.signal instanceof AbortSignal))
         throw new TypeError('Native AbortSignal required');
     return { ...(selectors ? { selectors } : {}), ...(data.service === undefined ? {} : { service: name(data.service) }),
+        ...(data.sourceCorrectionsFile === undefined ? {} : { sourceCorrectionsFile: text(data.sourceCorrectionsFile) }),
         ...(Object.hasOwn(data, 'applicationGroups') ? { applicationGroups: parseApplicationGroups(data.applicationGroups) } : {}),
         ...(data.port === undefined ? {} : { port: text(data.port) }), ...(fileRoots ? { fileRoots } : {}),
         ...(sourceResources ? { sourceResources } : {}), ...(sourceOrigins ? { sourceOrigins } : {}),
@@ -149,6 +152,98 @@ function parseComponentOptions(value, resolved) {
         ...(standardLibraries ? { standardLibraries } : {}), ...(recordProjections ? { recordProjections } : {}),
         ...(namespaceLocations ? { namespaceLocations } : {}), ...(basePath ? { basePath } : {}), ...(data.signal ? { signal: data.signal } : {}) };
 }
+/**
+ * Acquire the complete authorized original source closure for correction and diagnostic inventory.
+ * @param source Main source location, retaining its configured logical URI.
+ * @param config Explicit loading scope and companion sources.
+ * @param acquiredMain Already acquired main closure, reused without another source read.
+ * @returns Original main and companion inputs with their shared loading policy and work accounting.
+ * @throws For unavailable or unauthorized sources and exhausted source limits.
+ * @constraints Acquisition does not qualify sources or grant response authority.
+ */
+export async function acquireCheckedSourceInputs(source, config, acquiredMain) {
+    const tick = () => config.signal?.throwIfAborted();
+    const budget = createApplicationBudget();
+    tick();
+    const loading = { policy: { fileRoots: config.fileRoots, allowedOrigins: config.sourceOrigins },
+        namespaceLocations: new Map(config.namespaceLocations?.map(item => [item.namespace, item.location])), signal: config.signal,
+        limits: acquiredMain?.limits, chargeWork: amount => { tick(); budget.chargeWork(amount); } };
+    const acquire = async (reference, main) => {
+        tick();
+        const prepared = await prepareSchemaSnapshotFiles(reference, config.sourceResources, { ...loading,
+            ...(main && config.sourceUri ? { sourceUri: config.sourceUri } : {}) });
+        return loadSemanticSchemaInput(main && config.sourceUri ? config.sourceUri : prepared.source, prepared.loading);
+    };
+    const main = acquiredMain ?? await acquire(source, true);
+    loading.limits = main.limits;
+    const companions = new Map();
+    for (const projection of config.recordProjections ?? []) {
+        tick();
+        const key = resolveResourceUri(projection.source);
+        if (!companions.has(key))
+            companions.set(key, key === main.root.uri ? main : await acquire(projection.source, false));
+    }
+    return { main, companions, loading };
+}
+/** Correct and reload the complete authorized project closure without mutating original sources. */
+export async function prepareCheckedSourceInputs(source, config, acquiredMain) {
+    if (!config.sourceCorrectionsFile)
+        throw new TypeError('Source correction preparation requires sourceCorrectionsFile');
+    const { main, companions, loading } = await acquireCheckedSourceInputs(source, config, acquiredMain);
+    const tick = () => config.signal?.throwIfAborted();
+    const recipeFile = path.resolve(config.sourceCorrectionsFile);
+    tick();
+    const handle = await fs.promises.open(recipeFile, 'r');
+    let bytes;
+    try {
+        const stat = await handle.stat();
+        const maximum = Math.min(main.limits.resourceBytes, bufferConstants.MAX_LENGTH - 1);
+        if (!stat.isFile() || !Number.isSafeInteger(stat.size) || stat.size > maximum)
+            throw new RangeError('Source correction recipe exceeds the source resource byte capacity');
+        // @constraints One extra byte detects growth without permitting an unbounded read after the size check.
+        const buffer = Buffer.alloc(stat.size + 1);
+        let offset = 0;
+        while (offset < buffer.length) {
+            tick();
+            const result = await handle.read(buffer, offset, buffer.length - offset, null);
+            if (!result.bytesRead)
+                break;
+            offset += result.bytesRead;
+        }
+        tick();
+        if (offset !== stat.size)
+            throw new TypeError('Source correction recipe changed during acquisition');
+        bytes = buffer.subarray(0, offset);
+        loading.chargeWork?.(512 + bytes.byteLength * 8);
+    }
+    finally {
+        await handle.close();
+    }
+    tick();
+    let recipe;
+    try {
+        recipe = JSON.parse(bytes.toString('utf8'));
+    }
+    catch {
+        throw new SourceCorrectionError('invalid-recipe', 'Source correction file must contain valid JSON');
+    }
+    const corrected = prepareCorrectedSourceInputs([main, ...companions.values()], recipe, config.signal);
+    const effective = new Map();
+    const reload = async (input) => {
+        const previous = effective.get(input.root.uri);
+        if (previous)
+            return previous;
+        const result = await loadSemanticSchemaInput(input.root.uri, { ...loading, offlineResources: corrected.resources });
+        effective.set(input.root.uri, result);
+        return result;
+    };
+    const effectiveMain = await reload(main);
+    const effectiveCompanions = new Map();
+    for (const [key, input] of companions)
+        effectiveCompanions.set(key, await reload(input));
+    return { main: effectiveMain, companions: effectiveCompanions, provenance: { ...corrected.provenance,
+            recipeFile: { digest: createHash('sha256').update(bytes).digest('hex') } } };
+}
 /**
  * Generate the bounded preview without creating a flattened catalog authority.
  * @param opts Public pipeline options with the checked model explicitly selected.
@@ -210,7 +305,9 @@ export async function runCheckedPipeline(opts) {
         basePath: planning.config.basePath ?? `/${versionSlug}/${serviceSlug}` }, planning.native, planning.report);
 }
 /** Prepare through native owners only; internal handles remain within this invocation. */
-export async function prepareComponentStages(wsdl, config, acquired, outputs = { clientDir: 'client', gatewayDir: 'gateway', openapiFile: 'openapi.json', basePath: '/v1/service' }) {
+export async function prepareComponentStages(wsdl, config, acquired, outputs = { clientDir: 'client', gatewayDir: 'gateway', openapiFile: 'openapi.json', basePath: '/v1/service' }, sourcePreparation) {
+    const correctedSources = sourcePreparation ?? (config.sourceCorrectionsFile ? await prepareCheckedSourceInputs(wsdl, config, acquired) : undefined);
+    acquired = correctedSources?.main ?? acquired;
     const tick = () => { if (config.signal?.aborted)
         throw new Error('Checked component generation cancelled'); };
     const namespaces = new Map(config.namespaceLocations?.map(location => [location.namespace, location.location]));
@@ -242,10 +339,16 @@ export async function prepareComponentStages(wsdl, config, acquired, outputs = {
     for (const group of groups.values()) {
         tick();
         const first = group[0];
-        const source = await prepareSchemaSnapshotFiles(first.source, config.sourceResources, { policy: {
-                fileRoots: config.fileRoots, allowedOrigins: config.sourceOrigins
-            }, namespaceLocations: namespaces,
-            limits: directLoadingLimits(budget), signal: config.signal, chargeWork: amount => { tick(); budget.chargeWork(amount); } });
+        const companionInput = correctedSources?.companions.get(resolveResourceUri(first.source));
+        const companionOffline = companionInput ? new Map([...companionInput.resourceAliases].map(([alias, uri]) => {
+            const resource = companionInput.resources.find(item => item.uri === uri);
+            return [alias, { bytes: copyOriginalSchemaResource(companionInput, uri, loading.chargeWork), digest: resource.digest, canonicalUri: uri }];
+        })) : undefined;
+        const source = companionInput ? { source: companionInput.root.uri, loading: { ...loading, offlineResources: companionOffline } }
+            : await prepareSchemaSnapshotFiles(first.source, config.sourceResources, { policy: {
+                    fileRoots: config.fileRoots, allowedOrigins: config.sourceOrigins
+                }, namespaceLocations: namespaces,
+                limits: directLoadingLimits(budget), signal: config.signal, chargeWork: amount => { tick(); budget.chargeWork(amount); } });
         const companions = await selectComponentOperations(source.source, group.map(item => item.recordSelector), { loading: source.loading,
             signal: config.signal, standardLibraries: first.standardLibraries?.map(acquireStandardSchemaLibrary) });
         for (const [index, entry] of group.entries()) {
@@ -340,7 +443,8 @@ export async function prepareComponentStages(wsdl, config, acquired, outputs = {
             }
         }
     }
-    return { expected, projections, namespaces, refusals, layout, generatedClients, gateway, applicationGroups };
+    return { expected, projections, namespaces, refusals, layout, generatedClients, gateway, applicationGroups,
+        ...(correctedSources ? { sourceCorrections: correctedSources.provenance } : {}) };
 }
 function prepareComponentLayout(expected, projections, tick) {
     const inspection = inspectDirectOperation(expected[0].contract), input = inspection.source;
@@ -421,6 +525,12 @@ async function runComponentStages(opts, config, outputs, native, report) {
         ...(native.applicationGroups ? { applicationGroups: native.applicationGroups } : {}),
         selection: { selector: config.selectors[0], selectors: config.selectors, service: config.service, port: config.port }, operations };
     fs.writeFileSync(path.join(clientDir, 'inventory.json'), JSON.stringify(inventory, null, 2) + '\n');
+    // @why This generator-owned manifest must describe the current generation, including removal of corrections.
+    const correctionManifest = path.join(clientDir, 'source-corrections.json');
+    if (native.sourceCorrections)
+        fs.writeFileSync(correctionManifest, JSON.stringify(native.sourceCorrections, null, 2) + '\n');
+    else
+        fs.rmSync(correctionManifest, { force: true });
     const component = { source: root, capsules: Object.fromEntries(Object.entries(contracts).map(([name, file]) => [name, path.resolve(clientDir, file)])),
         sourceResources, sourceOrigins: config.sourceOrigins, ...(new URL(input.root.uri).protocol === 'file:' ? {} : { sourceUri: input.root.uri }),
         ...(namespaceLocations.length ? { namespaceLocations } : {}),

package/dist/checkedPlanning.d.ts

@@ -1,6 +1,7 @@
 import { prepareComponentStages } from './checkedPipeline.js';
-import type { CheckedComponentOptions } from './checkedPipeline.js';
+import type { CheckedComponentOptions, PreparedCheckedSourceInputs } from './checkedPipeline.js';
 import type { DirectOperationSelector } from './compiler/directOperation.js';
+import type { SchemaInput } from './loader/schemaInput.js';
 import type { ExpandedName } from './loader/orderedSyntax.js';
 type Category = 'missing-dependency' | 'permission' | 'ambiguous-selection' | 'invalid-source' | 'unsupported-capability' | 'inconclusive' | 'cancelled' | 'resource-limit' | 'operational-failure' | 'configuration';
 export interface ComponentPlanBlocker {
@@ -115,9 +116,11 @@ export declare function prepareCheckedComponentPlan(source: string, choices?: un
     gatewayDir: string;
     openapiFile: string;
     basePath: string;
-}): Promise<{
+}, inspectionSelector?: DirectOperationSelector): Promise<{
     report: CheckedComponentPlan;
     config?: CheckedComponentOptions;
     native?: Awaited<ReturnType<typeof prepareComponentStages>>;
+    sources?: PreparedCheckedSourceInputs;
+    sourceInput?: SchemaInput;
 }>;
 export {};

package/dist/checkedPlanning.js

@@ -6,9 +6,10 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { types } from 'node:util';
-import { parseCheckedComponentOptions, parseCheckedComponentChoices, prepareComponentStages } from './checkedPipeline.js';
+import { parseCheckedComponentOptions, parseCheckedComponentChoices, prepareComponentStages, prepareCheckedSourceInputs } from './checkedPipeline.js';
 import { inspectDirectOperation } from './compiler/directOperation.js';
 import { loadSemanticSchemaInput, prepareSchemaSnapshotFiles } from './loader/schemaInput.js';
+import { SourceCorrectionError } from './compiler/sourceCorrections.js';
 import { resolveResourceUri } from './loader/schemaResources.js';
 import { syntaxElements, syntaxAttribute, resolveLexicalQName, WSDL_NAMESPACE, XSD_NAMESPACE, SchemaLoadingError } from './loader/orderedSyntax.js';
 const same = (a, b) => a.namespace === b.namespace && a.local === b.local;
@@ -55,7 +56,7 @@ export function writeCheckedPlanningFile(file, value, force = false) {
     fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\n', { flag: force ? 'w' : 'wx' });
 }
 // @constraints Internal composition only. Native handles are never attached to the public report.
-export async function prepareCheckedComponentPlan(source, choices = {}, outputs) {
+export async function prepareCheckedComponentPlan(source, choices = {}, outputs, inspectionSelector) {
     const documents = [], blockers = [];
     let complete = false, config;
     let intake;
@@ -104,6 +105,8 @@ export async function prepareCheckedComponentPlan(source, choices = {}, outputs)
         order(operations);
     };
     let native;
+    let correctedSources;
+    let sourceInput;
     let preparingNative = false;
     try {
         if (!choices || typeof choices !== 'object' || types.isProxy(choices) || ![null, Object.prototype].includes(Object.getPrototypeOf(choices)))
@@ -136,7 +139,25 @@ export async function prepareCheckedComponentPlan(source, choices = {}, outputs)
                 namespaceLocations: new Map(intake.namespaceLocations?.map(n => [n.namespace, n.location])),
                 onDocument: (document) => { documents.push(document); } };
             const prepared = Object.hasOwn(explicit, 'sourceResources') ? await prepareSchemaSnapshotFiles(source, intake.sourceResources, loading) : undefined;
-            const input = await loadSemanticSchemaInput(intake.sourceUri ?? prepared?.source ?? source, prepared?.loading ?? loading);
+            let input = await loadSemanticSchemaInput(intake.sourceUri ?? prepared?.source ?? source, prepared?.loading ?? loading);
+            sourceInput = input;
+            correctedSources = intake.sourceCorrectionsFile ? await prepareCheckedSourceInputs(source, intake, input) : undefined;
+            if (correctedSources) {
+                input = correctedSources.main;
+                sourceInput = input;
+                documents.splice(0, documents.length, ...input.documents);
+            }
+            // @why Correction pins authenticate the complete project closure. Narrow only
+            //   after preparation, so inspecting one operation cannot discard pinned companions.
+            if (inspectionSelector) {
+                const selected = (candidate) => candidate.operation === inspectionSelector.operation
+                    && same(candidate.portType, inspectionSelector.portType) && same(candidate.binding, inspectionSelector.binding);
+                if (intake.selectors && !intake.selectors.some(selected))
+                    throw new TypeError('Inspection selector is not a configured operation');
+                intake = { ...intake, selectors: [inspectionSelector],
+                    ...(intake.recordProjections ? { recordProjections: intake.recordProjections.filter(entry => selected(entry.selector)) } : {}) };
+                explicit.selectors = [inspectionSelector];
+            }
             complete = true;
             inventory();
             const possible = candidates.filter(c => (!Object.hasOwn(explicit, 'service') || intake.service !== undefined && same(c.service, intake.service))
@@ -178,7 +199,7 @@ export async function prepareCheckedComponentPlan(source, choices = {}, outputs)
                 config = { ...config, sourceResources: [...config.sourceResources, ...input.resources.filter(r => r.uri !== input.root.uri && !known.has(r.uri) && new URL(r.uri).protocol === 'file:')
                             .map(r => ({ uri: r.uri, file: fileURLToPath(r.uri) }))] };
                 preparingNative = true;
-                native = await prepareComponentStages(source, config, !prepared && new URL(input.root.uri).protocol !== 'file:' ? input : undefined, outputs);
+                native = await prepareComponentStages(source, config, correctedSources ? input : !prepared && new URL(input.root.uri).protocol !== 'file:' ? input : undefined, outputs, correctedSources);
                 if (native.expected.length) {
                     const fresh = inspectDirectOperation(native.expected[0].contract).source;
                     if (input.resources.length !== fresh.resources.length || input.resources.some(r => !fresh.resources.some(n => n.uri === r.uri && n.digest === r.digest))) {
@@ -233,6 +254,9 @@ export async function prepareCheckedComponentPlan(source, choices = {}, outputs)
         }
         if (intake?.signal?.aborted)
             add('cancelled', complete ? 'native-preparation' : 'loading', 'caller-cancelled', 'Rerun with an active signal.', 'signal');
+        else if (error instanceof SourceCorrectionError) {
+            add(error.category === 'resource-limit' ? 'resource-limit' : error.category === 'cancelled' ? 'cancelled' : 'configuration', 'configuration', `source-corrections:${error.category}`, 'Review the pinned correction file against the original source inventory; regenerate stale drafts or supply replacement snapshots for unsupported edits.', 'checkedComponents.sourceCorrectionsFile', selectors);
+        }
         else if (error instanceof SchemaLoadingError && error.message === 'Duplicate logical schema snapshot') {
             add('configuration', 'configuration', 'duplicate-logical-snapshot', 'Supply unique logical snapshot identities.', 'checkedComponents.sourceResources');
         }
@@ -264,5 +288,6 @@ export async function prepareCheckedComponentPlan(source, choices = {}, outputs)
                 instructions: 'Save configuration as checked JSON. Replace REQUIRED_SCHEMA_LOCATION with an authorized schema path; paths resolve from the invocation working directory. Rerun the same pipeline with --checked-config. Reports never authorize generation.',
                 configuration: { ...Object.fromEntries(Object.entries(explicit).filter(([key]) => key !== 'signal')), namespaceLocations: unresolved }
             } } : {}) };
-    return { report, ...(config ? { config } : {}), ...(native ? { native } : {}) };
+    return { report, ...(config ? { config } : {}), ...(native ? { native } : {}), ...(correctedSources ? { sources: correctedSources } : {}),
+        ...(sourceInput ? { sourceInput } : {}) };
 }

package/dist/checkedResponseInspection.d.ts

@@ -0,0 +1,100 @@
+import type { CheckedComponentOptions } from './checkedPipeline.js';
+import type { DirectOperationSelector } from './compiler/directOperation.js';
+import type { ObservedSoapResponseMetadata } from './compiler/directSoap.js';
+import type { DirectXmlLimits } from './compiler/directCodec.js';
+export interface CheckedResponseInspectionOptions {
+    readonly checkedComponents?: Partial<CheckedComponentOptions>;
+    readonly selector: DirectOperationSelector;
+    readonly responseBytes: Uint8Array;
+    readonly responseMetadata?: ObservedSoapResponseMetadata;
+    readonly signal?: AbortSignal;
+    readonly limits?: DirectXmlLimits;
+    readonly includeCorrectionDraft?: boolean;
+}
+type Assessment = 'conforming' | 'mismatch' | 'refused' | 'unassessed';
+interface ScopedOutcome {
+    readonly assessment: Assessment;
+    readonly rule?: string;
+}
+interface InspectionLocation {
+    readonly resource: string;
+    readonly digest: string;
+    readonly path: string;
+    readonly line: number;
+    readonly column: number;
+}
+interface InspectionDiagnostic {
+    readonly scope: 'preparation' | 'response' | 'wrapper' | 'companion';
+    readonly kind: string;
+    readonly rule: string;
+    readonly guidance: string;
+    readonly source?: InspectionLocation;
+    readonly schemaPath?: string;
+    readonly payloadPath?: string;
+}
+/** A non-applicable recipe draft; null fields require an explicit consumer decision.
+ * @since Unreleased
+ */
+export interface CheckedResponseCorrectionDraft {
+    readonly version: 1;
+    readonly resources: readonly {
+        readonly uri: string;
+        readonly digest: string;
+    }[];
+    readonly corrections: readonly Readonly<Record<string, unknown>>[];
+}
+/** Bounded diagnostic data without XML, application values, native handles or acceptance authority.
+ * @since Unreleased
+ */
+export interface CheckedResponseInspectionReport {
+    readonly version: 'checked-response-inspection-v1';
+    readonly kind: 'conforming' | 'mismatch' | 'refused';
+    readonly scope: 'xml-only' | 'full-response';
+    readonly admitted: false;
+    readonly executed: false;
+    readonly selector: DirectOperationSelector;
+    readonly response: {
+        readonly digest?: string;
+        readonly digestAssessment: 'computed' | 'unassessed-limit' | 'unassessed-cancelled';
+        readonly byteLength: number;
+    };
+    readonly http: {
+        readonly assessment: Assessment | 'not-established';
+        readonly status?: number;
+    };
+    readonly fault: {
+        readonly assessment: 'unassessed' | 'conforming';
+        readonly observed?: boolean;
+        readonly declared?: boolean;
+    };
+    readonly resources: readonly {
+        readonly resource: string;
+        readonly digest: string;
+    }[];
+    readonly outcomes: {
+        readonly response: ScopedOutcome;
+        readonly wrapper?: ScopedOutcome;
+        readonly companion?: ScopedOutcome;
+    };
+    readonly diagnostics: readonly InspectionDiagnostic[];
+    readonly correctionDraft?: CheckedResponseCorrectionDraft;
+    readonly sourceCorrections?: {
+        readonly recipeDigest: string;
+        readonly resources: readonly {
+            readonly resource: string;
+            readonly originalDigest: string;
+            readonly effectiveDigest: string;
+            readonly changed: boolean;
+        }[];
+    };
+    readonly truncated: boolean;
+}
+/** Inspect actual caller-owned SOAP bytes without constructing a request or contacting any endpoint.
+ * @param source Local WSDL path, retaining optional configured logical snapshot identities.
+ * @param options Full operation selector, closed checked choices, actual bytes and optional actual HTTP metadata.
+ * @returns A bounded value-redacted report; independently conforming companion diagnostics never erase outer failures.
+ * @throws TypeError For malformed invocation data; RangeError for invalid capacities; filesystem errors for unavailable input files.
+ * @sideEffects Reads authorized local metadata only; creates no files and performs no SOAP transport.
+ */
+export declare function inspectCheckedResponse(source: string, options: CheckedResponseInspectionOptions): Promise<CheckedResponseInspectionReport>;
+export {};