@wirebench/engine 2.1.1

package/dist/soap/transforms.js

@@ -0,0 +1,164 @@
+/**
+ * The envelope transforms applied on the way out, per request property:
+ * "Remove Empty Content", "Strip Whitespaces", "Pretty Print" and "Entitize Properties".
+ *
+ * All four are text transforms over a tolerant tokenizer, never a DOM round trip: an envelope
+ * a user hand-edited may not be well formed, and a transform that throws (or silently rewrites
+ * attribute quoting) on the way to the wire is worse than one that does nothing. Every function
+ * here returns its input unchanged when it cannot understand the document.
+ *
+ * Entitizing is the odd one out. It escapes the values substituted by property expansion,
+ * which cannot be identified after the fact — by the time an envelope is a string, a `&` that
+ * came from a property is indistinguishable from one the user typed. So {@link entitizeValue}
+ * is applied *during* expansion instead (see `project/properties.ts`'s `entitize` option), and
+ * lives here alongside its siblings.
+ */
+import { formatXml } from '../xml/pretty.js';
+import { buildRangeTree, localNameOf, tokenizeXml } from '../xml/tolerant-tree.js';
+/** SOAP wrapper elements that "Remove Empty Content" must never delete. */
+const WRAPPERS = new Set(['Envelope', 'Header', 'Body']);
+/** The `?` the sample generator writes for an untouched leaf. */
+const PLACEHOLDER_ONLY = /^[\s?]*$/;
+/**
+ * True when this element carries nothing worth sending: no attributes, no element children
+ * that survived, and inner text that is empty, whitespace, or only `?` placeholders. A CDATA
+ * section, a comment or a processing instruction counts as content.
+ */
+function isEmptyElement(node, removed) {
+    if (WRAPPERS.has(localNameOf(node.name))) {
+        return false;
+    }
+    if (node.rawAttrs !== '') {
+        return false;
+    }
+    if (node.children.some((child) => !removed.has(child))) {
+        return false;
+    }
+    for (const token of node.leafTokens) {
+        if (token.kind !== 'text') {
+            return false;
+        }
+        if (!PLACEHOLDER_ONLY.test(token.raw)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Collects every element that should disappear, deepest first so parents see their children's fate. */
+function collectRemovals(nodes, removed) {
+    for (const node of nodes) {
+        collectRemovals(node.children, removed);
+        if (isEmptyElement(node, removed)) {
+            removed.add(node);
+        }
+    }
+}
+/** Deletes `ranges` (non-overlapping, any order) from `text`. */
+function cut(text, ranges) {
+    const sorted = [...ranges].sort((a, b) => a.start - b.start);
+    let out = '';
+    let cursor = 0;
+    for (const range of sorted) {
+        if (range.start < cursor) {
+            continue;
+        }
+        out += text.slice(cursor, range.start);
+        cursor = range.end;
+    }
+    return out + text.slice(cursor);
+}
+/**
+ * "Remove Empty Content": drops every element that has no attributes and whose whole
+ * content is empty, whitespace, or `?` placeholders — recursively, so a parent left with
+ * nothing but removed children goes too. The `Envelope`/`Header`/`Body` wrappers are never
+ * removed, however empty they are.
+ *
+ * @param xml the envelope text
+ * @returns the transformed envelope, or `xml` unchanged when it could not be parsed
+ */
+export function removeEmptyContent(xml) {
+    const tokens = tokenizeXml(xml);
+    if (tokens === undefined) {
+        return xml;
+    }
+    const roots = buildRangeTree(tokens);
+    if (roots === undefined) {
+        return xml;
+    }
+    const removed = new Set();
+    collectRemovals(roots, removed);
+    if (removed.size === 0) {
+        return xml;
+    }
+    // Only outermost removals matter: cutting a parent already takes its children with it.
+    const outermost = [];
+    const walk = (nodes) => {
+        for (const node of nodes) {
+            if (removed.has(node)) {
+                outermost.push(node);
+                continue;
+            }
+            walk(node.children);
+        }
+    };
+    walk(roots);
+    // Trailing whitespace on the line the element sat on goes with it, so removing a child does
+    // not leave a blank, indented line behind.
+    const ranges = outermost.map((node) => {
+        let start = node.start;
+        while (start > 0 && (xml[start - 1] === ' ' || xml[start - 1] === '\t')) {
+            start -= 1;
+        }
+        let end = node.end;
+        if (start > 0 && xml[start - 1] === '\n') {
+            // Keep the newline that *precedes* the element only if the element is not the whole line.
+            if (xml[end] === '\n') {
+                end += 1;
+            }
+        }
+        return { start, end };
+    });
+    return cut(xml, ranges);
+}
+/**
+ * "Strip Whitespaces": drops whitespace-only text nodes between elements and trims
+ * the leading/trailing whitespace of every other text node. CDATA sections, comments and
+ * processing instructions are left exactly as they are.
+ *
+ * @param xml the envelope text
+ * @returns the transformed envelope, or `xml` unchanged when it could not be tokenized
+ */
+export function stripWhitespaces(xml) {
+    const tokens = tokenizeXml(xml);
+    if (tokens === undefined) {
+        return xml;
+    }
+    let out = '';
+    for (const token of tokens) {
+        out += token.kind === 'text' ? token.raw.trim() : token.raw;
+    }
+    return out;
+}
+/**
+ * "Pretty Print": reformats the envelope with the given indent width.
+ *
+ * @param xml the envelope text
+ * @param indentWidth spaces per nesting level; defaults to 3, the editor's default tab size
+ * @returns the formatted envelope, or `xml` unchanged when it could not be formatted
+ */
+export function prettyPrint(xml, indentWidth = 3) {
+    const result = formatXml(xml, { indent: ' '.repeat(Math.max(0, indentWidth)) });
+    return result.problem === undefined ? result.text : xml;
+}
+/**
+ * "Entitize Properties", applied to one substituted property value: escapes the three
+ * characters that would otherwise be read as markup once the value lands inside an envelope.
+ *
+ * `"` and `'` are deliberately left alone: expansion targets element content far more often
+ * than an attribute value, and escaping quotes there would show up as `&quot;` in the payload.
+ *
+ * @param value the expanded property value
+ */
+export function entitizeValue(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}

package/dist/types.d.ts

@@ -0,0 +1,307 @@
+/**
+ * Facade-level types tying Tasks 5-10 together: importing a WSDL definition
+ * and sending a SOAP request. These are the shapes the desktop app (Task 13)
+ * consumes directly.
+ */
+import type { FetchDocument } from './wsdl/resolver.js';
+import type { QName } from './wsdl/qname.js';
+import type { DefinitionBundle } from './wsdl/resolver.js';
+import type { MimePartInfo, WsdlDefinition } from './wsdl/model.js';
+import type { SchemaSet } from './xsd/schema-set.js';
+import type { HttpExchange, ProxyOptions, TlsOptions } from './http/types.js';
+import type { SoapEnvelopeVersion } from './soap/envelope.js';
+import type { SoapFault } from './soap/fault.js';
+import type { UnresolvedRef } from './project/properties.js';
+import type { Attachment } from './project/model.js';
+import type { AttachmentResolver, ResponseAttachment } from './soap/mime/types.js';
+import type { WssContext, WssIncomingConfig, WssOutgoingConfig } from './wss/model.js';
+import type { WssResult } from './wss/incoming/index.js';
+import type { WssRequestProperties } from './wss/apply.js';
+import type { WsaConfig } from './wsa/model.js';
+import type { WsaSummary } from './wsa/policy-detect.js';
+/** Where a WSDL definition comes from. */
+export type ImportSource = {
+    readonly kind: 'url';
+    readonly url: string;
+} | {
+    readonly kind: 'file';
+    readonly path: string;
+} | {
+    readonly kind: 'text';
+    readonly text: string;
+    /** Base location for resolving relative imports; defaults to `inline:wsdl`. */
+    readonly location?: string;
+};
+/** One phase of an in-progress {@link ImportSource} import. */
+export type ImportProgress = {
+    readonly phase: 'fetch';
+    readonly location: string;
+} | {
+    readonly phase: 'parse';
+} | {
+    readonly phase: 'schema';
+} | {
+    readonly phase: 'done';
+};
+/**
+ * Definition-cache behaviour for `importDefinition`: `'prefer-cache'` resolves
+ * entirely from a valid cache with no network access (falling back to the
+ * network, with a problem reported, if the cache is missing or corrupt);
+ * `'refresh'` always resolves from the network and then (re)writes the
+ * cache; `'none'` ignores the cache entirely.
+ */
+export interface ImportCacheOptions {
+    /** Absolute path of the interface's `definition/` directory (see `definitionCacheDir`). */
+    readonly dir: string;
+    readonly mode: 'prefer-cache' | 'refresh' | 'none';
+}
+/** Options accepted by `importDefinition`. */
+export interface ImportOptions {
+    /** Overrides the default `file://`/`http(s)://` fetcher, e.g. for tests. */
+    readonly fetchDocument?: FetchDocument;
+    /** Basic auth credentials added to every `http(s)://` fetch made while importing. */
+    readonly auth?: {
+        readonly username: string;
+        readonly password: string;
+    };
+    readonly signal?: AbortSignal;
+    readonly onProgress?: (event: ImportProgress) => void;
+    /** Definition-cache behaviour; see {@link ImportCacheOptions}. Omitted/absent means no caching. */
+    readonly cache?: ImportCacheOptions;
+}
+/** A non-fatal problem encountered while importing a definition, tagged by the stage that raised it. */
+export interface ImportProblem {
+    readonly source: 'resolve' | 'wsdl' | 'schema';
+    readonly code: string;
+    readonly message: string;
+    readonly location?: string;
+    readonly line?: number;
+    readonly column?: number;
+}
+/** One binding operation's port bindings, as summarized for a picker UI. */
+export interface OperationSummary {
+    readonly bindingName: QName;
+    readonly operationName: string;
+    readonly soapVersion: '1.1' | '1.2' | 'none';
+    readonly soapAction?: string;
+    readonly style: 'document' | 'rpc';
+    readonly documentation?: string;
+    readonly ports: readonly {
+        readonly serviceName: QName;
+        readonly portName: string;
+        readonly address?: string;
+    }[];
+    /**
+     * The `mime:multipartRelated` attachment parts declared for this operation's input, in document
+     * order; empty when the input is a plain `soap:body`. Drives the request editor's "Part" column.
+     */
+    readonly inputMimeParts: readonly MimePartInfo[];
+}
+/** The full result of importing a WSDL definition: parsed model, schema set, problems and an operation picker list. */
+export interface ImportResult {
+    readonly definition: WsdlDefinition;
+    readonly bundle: DefinitionBundle;
+    readonly schemaSet: SchemaSet;
+    readonly problems: readonly ImportProblem[];
+    readonly operations: readonly OperationSummary[];
+    /** What the definition itself says about WS-Addressing; see `summarizeWsa`. */
+    readonly wsa: WsaSummary;
+    /** True when this result was resolved entirely from the definition cache, with no network access. */
+    readonly fromCache?: boolean;
+}
+/**
+ * Credentials for one send, already resolved to plaintext: the desktop app looks a
+ * `passwordRef` up in its secret store before calling the engine, so the engine never
+ * sees a secret reference (and never persists or logs the password).
+ */
+export type SendAuth = {
+    readonly type: 'basic';
+    readonly username: string;
+    readonly password: string;
+    /** Send the `Authorization` header on the first attempt instead of waiting for a 401. */
+    readonly preemptive: boolean;
+} | {
+    readonly type: 'ntlm';
+    readonly username: string;
+    readonly password: string;
+    readonly domain?: string;
+    readonly workstation?: string;
+}
+/** A token in an `Authorization` header. `scheme` defaults to `Bearer`. */
+ | {
+    readonly type: 'bearer';
+    readonly token: string;
+    readonly scheme?: string;
+}
+/** A key in one header or one query parameter. */
+ | {
+    readonly type: 'api-key';
+    readonly name: string;
+    readonly value: string;
+    readonly in: 'header' | 'query';
+}
+/**
+ * An OAuth2 access token the host already obtained. The engine never runs a grant during a send:
+ * the token is fetched (and cached, and refreshed) by the host, so a send is one exchange and
+ * the browser is never opened behind it. On the wire it is a Bearer token.
+ */
+ | {
+    readonly type: 'oauth2';
+    readonly accessToken: string;
+};
+/** What authentication actually did during one send, for the UI to explain the exchange. */
+export interface AuthSummary {
+    readonly scheme: SendAuth['type'];
+    /** True when the server answered the first attempt with a 401 challenge. */
+    readonly challenged: boolean;
+    /**
+     * How many HTTP attempts the send made: 1 preemptive/unchallenged, 2 after a Basic
+     * challenge, 3 for a full NTLM handshake (bare, Type 1, Type 3).
+     */
+    readonly attempts: 1 | 2 | 3;
+}
+/** Input to `sendSoapRequest`: an already-built envelope plus transport knobs. */
+export interface SoapSendInput {
+    readonly endpoint: string;
+    readonly envelopeXml: string;
+    readonly soapVersion: '1.1' | '1.2';
+    readonly soapAction?: string;
+    /** Extra/override HTTP headers; a caller-provided Content-Type or SOAPAction overrides the computed ones. */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Milliseconds before the request is aborted. Default 60000. */
+    readonly timeoutMs?: number;
+    /** Default 'utf-8'; charset in Content-Type and body encoding. Other encodings use node Buffer when supported. */
+    readonly encoding?: string;
+    /** Default false. */
+    readonly followRedirects?: boolean;
+    readonly maxSizeBytes?: number;
+    readonly skipSoapAction?: boolean;
+    /** Local network interface address to bind the outgoing socket to ("Bind Address"). */
+    readonly localAddress?: string;
+    /** Compress the request body and set `Content-Encoding` accordingly. Default: uncompressed. */
+    readonly compressBody?: 'gzip';
+    /**
+     * XML-escape every property value substituted into `envelopeXml` ("Entitize
+     * Properties"). Only meaningful when the send is given property scopes to expand against.
+     */
+    readonly entitize?: boolean;
+    readonly tls?: TlsOptions;
+    readonly proxy?: ProxyOptions;
+    /** Offer HTTP/2 in the TLS ALPN handshake. Off by default; see `HttpRequest.allowH2`. */
+    readonly allowH2?: boolean;
+    readonly signal?: AbortSignal;
+    /** Resolved credentials; see {@link SendAuth}. A caller-supplied `Authorization` header wins. */
+    readonly auth?: SendAuth;
+    /** Attachments to send; only acted on when {@link attachmentOptions} says how. */
+    readonly attachments?: readonly Attachment[];
+    /** MTOM/SwA/inline-file behaviour plus the resolvers that turn references into bytes. */
+    readonly attachmentOptions?: SendAttachmentOptions;
+    /**
+     * WS-Security applied to the envelope after property expansion and inline-file substitution
+     * and before attachment packaging, so the header is part of the envelope that actually goes
+     * on the wire (and that raw capture shows), and a signature covers the substituted bytes
+     * rather than the `file:` reference they replaced.
+     */
+    readonly wss?: SoapSendWss;
+    /**
+     * WS-Addressing applied to the envelope after property expansion and inline-file
+     * substitution, and *before* WS-Security, so a signature configured to cover the `wsa:*`
+     * headers can actually reach them.
+     */
+    readonly wsa?: SoapSendWsa;
+}
+/** The WS-Addressing half of a send: the effective configuration and what it needs to resolve. */
+export interface SoapSendWsa {
+    readonly config: WsaConfig;
+    /** The WSDL-derived default `wsa:Action` for this operation; see `defaultAction`. */
+    readonly defaultAction: string;
+    /** Mints the MessageID's UUID; defaults to `crypto.randomUUID`. Injected by golden tests. */
+    readonly uuid?: () => string;
+}
+/** The WS-Security half of a send: the configuration, its capabilities, and the overrides. */
+export interface SoapSendWss {
+    readonly outgoing?: WssOutgoingConfig;
+    /** Applied to the response: decryption, signature verification and timestamp freshness. */
+    readonly incoming?: WssIncomingConfig;
+    readonly ctx: WssContext;
+    readonly requestProperties?: WssRequestProperties;
+}
+/**
+ * How one send treats attachments: the request's own MTOM/SwA properties, plus the
+ * resolvers that read bytes (the engine never touches the file system on its own —
+ * see `createFileAttachmentResolver`).
+ *
+ * `expandMtomAttachments` and `inlineResponseAttachments` are separate knobs: the
+ * first replaces each `xop:Include` in the response envelope with the
+ * referenced part's base64, the second keeps those parts listed as attachments even
+ * once they have been expanded into the envelope.
+ */
+export interface SendAttachmentOptions {
+    /** Rewrite `cid:` references as `xop:Include` and send an MTOM package. */
+    readonly enableMtom: boolean;
+    /** Send an MTOM package even when nothing was optimised. */
+    readonly forceMtom: boolean;
+    /** Send the envelope alone; attachments (and MTOM) are skipped entirely. */
+    readonly disableMultiparts: boolean;
+    /** Base64 transfer encoding for SwA parts instead of binary. */
+    readonly encodeAttachments: boolean;
+    /**
+     * Replace `file:<path>` element text with the file's base64 before sending. Substitution
+     * happens with property expansion, *before* WS-Addressing and WS-Security, so what is signed
+     * is what is sent.
+     */
+    readonly enableInlineFiles: boolean;
+    /** Keep response parts listed as attachments even when they were expanded into the envelope. */
+    readonly inlineResponseAttachments: boolean;
+    /** Replace `xop:Include` in the response envelope with the referenced part's base64. */
+    readonly expandMtomAttachments: boolean;
+    readonly resolver: AttachmentResolver;
+    /** Reads one file for `enableInlineFiles`; without it, inline files are left alone. */
+    readonly resolveFile?: (path: string) => Promise<Uint8Array>;
+    /** Base directory for relative inline-file references. */
+    readonly resourceRoot?: string;
+}
+/** The result of sending a SOAP request: the raw HTTP exchange plus a structural read of the response. */
+export interface SoapExchange {
+    readonly http: HttpExchange;
+    readonly response?: {
+        /**
+         * Decoded body as text. When incoming WS-Security decrypted the response, this is the
+         * *restored* envelope: the raw bytes on `http` stay exactly as they arrived, so the Raw
+         * view shows ciphertext while the XML view shows plaintext.
+         */
+        readonly envelopeXml: string;
+        readonly version?: SoapEnvelopeVersion;
+        readonly fault?: SoapFault;
+        /** False when the body is not a SOAP envelope (an HTML error page, etc.). */
+        readonly isSoap: boolean;
+        /** Parts of a `multipart/related` response other than the envelope. */
+        readonly attachments?: readonly ResponseAttachment[];
+    };
+    /**
+     * Total time on the wire. For a challenged send ({@link AuthSummary.attempts} greater than 1 —
+     * a Basic retry or an NTLM handshake) this is the *sum* of every attempt, not just the final
+     * one, since all of them actually happened.
+     */
+    readonly durationMs: number;
+    readonly problems: readonly {
+        readonly code: 'not-soap' | 'xml-parse-error' | 'decode-error' | 'mime-parse' | 'inline-file-missing';
+        readonly message: string;
+    }[];
+    /** What authentication did, when the send was given {@link SoapSendInput.auth}. */
+    readonly auth?: AuthSummary;
+    /** Property expansions in the request that could not be resolved (set only when `options.scopes` was given). */
+    readonly unresolved?: readonly UnresolvedRef[];
+    /** What WS-Addressing put on the wire, when the send was given {@link SoapSendInput.wsa}. */
+    readonly wsa?: {
+        readonly messageId?: string;
+        readonly action?: string;
+    };
+    /** What WS-Security did, when the send was given {@link SoapSendInput.wss}. */
+    readonly wss?: {
+        /** The entry kinds applied to the outgoing envelope, in the order they were applied. */
+        readonly applied?: readonly string[];
+        /** What incoming processing made of the response, when the send was given a configuration. */
+        readonly incoming?: WssResult;
+    };
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * Facade-level types tying Tasks 5-10 together: importing a WSDL definition
+ * and sending a SOAP request. These are the shapes the desktop app (Task 13)
+ * consumes directly.
+ */
+export {};

package/dist/validate/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Message validation: the SOAP structure checks and the XSD schema validation
+ * behind one call.
+ *
+ * Structure runs first and schema only when the document is well formed —
+ * validating the body of a document libxml2 cannot parse produces nothing but
+ * noise, and the parse error is already reported with a position.
+ */
+import type { WsdlDefinition } from '../wsdl/model.js';
+import type { DefinitionBundle } from '../wsdl/resolver.js';
+import type { SchemaSet } from '../xsd/schema-set.js';
+import type { OperationRef } from '../soap/request-builder.js';
+import type { ValidationBinding, ValidationProblem } from './types.js';
+export type { ValidationBinding, ValidationPart, ValidationProblem, ValidationSeverity, ValidationSource, } from './types.js';
+export { checkSoapStructure, type SoapStructureOptions } from './soap-structure.js';
+export { validateAgainstSchemaSet, DEFAULT_VALIDATION_TIMEOUT_MS, type SchemaValidationOptions, type SchemaValidationTarget, } from './schema-validator.js';
+/** Which half of an exchange is being validated. */
+export type MessageDirection = 'request' | 'response';
+/** Everything {@link validateMessage} needs. */
+export interface ValidateMessageInput {
+    /** The whole envelope text, as typed in the editor or as received. */
+    readonly xml: string;
+    readonly direction: MessageDirection;
+    readonly schemaSet: SchemaSet;
+    readonly bundle: DefinitionBundle;
+    readonly binding: ValidationBinding;
+    /** The transport metadata to cross-check against the envelope's SOAP version. */
+    readonly http?: {
+        readonly contentType?: string;
+        readonly soapAction?: string;
+    };
+    /** Wall-clock budget for the schema half; see `DEFAULT_VALIDATION_TIMEOUT_MS`. */
+    readonly timeoutMs?: number;
+}
+/** What {@link validateMessage} reports. */
+export interface ValidateMessageResult {
+    readonly problems: readonly ValidationProblem[];
+    /** How long the whole validation took, in milliseconds. */
+    readonly durationMs: number;
+}
+/**
+ * Validates one SOAP message against its interface: SOAP structure first,
+ * then the XSD schema set (skipped when the message is not well formed).
+ *
+ * @param input the message, its binding context, and the schema set to validate against
+ * @returns every finding plus the wall-clock duration
+ */
+export declare function validateMessage(input: ValidateMessageInput): Promise<ValidateMessageResult>;
+/**
+ * Builds the {@link ValidationBinding} for one operation of a parsed
+ * definition: the SOAP version and style the binding declares, plus the
+ * `wsdl:part`s of the message on `direction`'s side.
+ *
+ * Returns `undefined` when the binding or operation is unknown, or when the
+ * binding is not a SOAP binding (there is nothing to validate against).
+ *
+ * @param definition the parsed WSDL
+ * @param op the binding operation the message belongs to
+ * @param direction `request` reads the operation's input message, `response` its output
+ */
+export declare function bindingContextFor(definition: WsdlDefinition, op: OperationRef, direction: MessageDirection): ValidationBinding | undefined;

package/dist/validate/index.js

@@ -0,0 +1,72 @@
+/**
+ * Message validation: the SOAP structure checks and the XSD schema validation
+ * behind one call.
+ *
+ * Structure runs first and schema only when the document is well formed —
+ * validating the body of a document libxml2 cannot parse produces nothing but
+ * noise, and the parse error is already reported with a position.
+ */
+import { findBinding, findMessage, findPortType } from '../wsdl/model.js';
+import { checkSoapStructure } from './soap-structure.js';
+import { validateAgainstSchemaSet } from './schema-validator.js';
+export { checkSoapStructure } from './soap-structure.js';
+export { validateAgainstSchemaSet, DEFAULT_VALIDATION_TIMEOUT_MS, } from './schema-validator.js';
+/**
+ * Validates one SOAP message against its interface: SOAP structure first,
+ * then the XSD schema set (skipped when the message is not well formed).
+ *
+ * @param input the message, its binding context, and the schema set to validate against
+ * @returns every finding plus the wall-clock duration
+ */
+export async function validateMessage(input) {
+    const started = performance.now();
+    const structure = checkSoapStructure(input.xml, {
+        expectedVersion: input.binding.soapVersion,
+        ...(input.http?.contentType !== undefined ? { contentType: input.http.contentType } : {}),
+        ...(input.http?.soapAction !== undefined ? { soapAction: input.http.soapAction } : {}),
+    });
+    if (structure.some((problem) => problem.code === 'xml-not-well-formed')) {
+        return { problems: structure, durationMs: performance.now() - started };
+    }
+    const schema = await validateAgainstSchemaSet(input.xml, { schemaSet: input.schemaSet, bundle: input.bundle }, { binding: input.binding, ...(input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs } : {}) });
+    return { problems: [...structure, ...schema], durationMs: performance.now() - started };
+}
+/**
+ * Builds the {@link ValidationBinding} for one operation of a parsed
+ * definition: the SOAP version and style the binding declares, plus the
+ * `wsdl:part`s of the message on `direction`'s side.
+ *
+ * Returns `undefined` when the binding or operation is unknown, or when the
+ * binding is not a SOAP binding (there is nothing to validate against).
+ *
+ * @param definition the parsed WSDL
+ * @param op the binding operation the message belongs to
+ * @param direction `request` reads the operation's input message, `response` its output
+ */
+export function bindingContextFor(definition, op, direction) {
+    const binding = findBinding(definition, op.bindingName);
+    if (binding === undefined || binding.soapVersion === 'none') {
+        return undefined;
+    }
+    const bindingOperation = binding.operations.find((candidate) => candidate.name === op.operationName);
+    if (bindingOperation === undefined) {
+        return undefined;
+    }
+    const abstract = findPortType(definition, binding.type)?.operations.find((candidate) => candidate.name === op.operationName);
+    const reference = direction === 'request' ? abstract?.input : abstract?.output;
+    const message = reference === undefined ? undefined : findMessage(definition, reference.message);
+    const declared = direction === 'request' ? bindingOperation.input?.body.parts : bindingOperation.output?.body.parts;
+    const parts = (message?.parts ?? [])
+        .filter((part) => declared === undefined || declared.includes(part.name))
+        .map((part) => ({
+        name: part.name,
+        ...(part.element !== undefined ? { element: part.element } : {}),
+        ...(part.type !== undefined ? { type: part.type } : {}),
+    }));
+    return {
+        soapVersion: binding.soapVersion,
+        operation: op.operationName,
+        style: bindingOperation.style ?? binding.style,
+        parts,
+    };
+}

package/dist/validate/schema-file-set.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Builds the in-memory libxml2 file set one bundle's schema documents compile into: every XSD
+ * (and every WSDL-embedded `<types>` schema) as its own synthetic file, one glue file per target
+ * namespace (so a namespace split across several documents can still be `xs:import`ed with a
+ * single reference), and the wrapper schema helpers that pull every namespace into one document
+ * a Body child can be validated against.
+ *
+ * Split out of `schema-validator.ts` (Task 42 fix round 1, minor 9): that module now only
+ * orchestrates validating a fragment against the set this one builds.
+ */
+import type { DefinitionBundle } from '../wsdl/resolver.js';
+import type { ValidationBinding } from './types.js';
+/** One in-memory file handed to libxml2. */
+export interface SchemaFile {
+    readonly fileName: string;
+    readonly contents: string;
+}
+/** The libxml2-ready form of one bundle: every schema as a file, plus one glue file per namespace. */
+export interface SchemaFileSet {
+    /** Every synthetic schema document, plus the per-namespace glue files. */
+    readonly files: readonly SchemaFile[];
+    /** Target namespace -> the glue file that pulls in every document contributing to it. */
+    readonly glue: ReadonlyMap<string, string>;
+    /** Synthetic files with no target namespace of their own (and not a chameleon include). */
+    readonly noNamespace: readonly string[];
+    /**
+     * Synthetic file name -> a human-readable label for where it came from: the original
+     * document's location for a `doc-N.xsd`/`embedded-N.xsd`, or `undefined` for a file this
+     * module invented itself (a glue file or a wrapper), which {@link fileSetLabels} reports as
+     * "the schema set".
+     */
+    readonly documentOf: ReadonlyMap<string, string>;
+}
+/** Builds (or returns the cached) libxml2 file set for `bundle`. */
+export declare function buildSchemaFileSet(bundle: DefinitionBundle): SchemaFileSet;
+/** The wrapper schema for `document` style: no declarations of its own, just every namespace. */
+export declare function documentWrapper(fileSet: SchemaFileSet): string;
+/**
+ * The wrapper schema for `rpc` style: the body child is the operation wrapper
+ * element, which no schema declares, so one is synthesized here with a child
+ * per `wsdl:part`. `xs:all` rather than `xs:sequence`, because `parameterOrder`
+ * (and sample generation) may order the parts differently from the
+ * `wsdl:message`, and part order is not something this validator should police.
+ */
+export declare function rpcWrapper(fileSet: SchemaFileSet, namespace: string, elementName: string, binding: ValidationBinding): string;
+/**
+ * Human-readable label for every synthetic file name a diagnostic might mention: the original
+ * document's location for a document file, or "the schema set" for anything this module
+ * invented (a glue file, or the caller's own wrapper/body files).
+ */
+export declare function fileSetLabels(fileSet: SchemaFileSet): ReadonlyMap<string, string>;