@wirebench/engine 2.1.1

package/dist/validate/schema-file-set.js

@@ -0,0 +1,288 @@
+/**
+ * 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 { NS } from '../xml/namespaces.js';
+import { serializeXml } from '../xml/serialize.js';
+import { childElements, firstChildElement } from '../wsdl/dom-utils.js';
+import { escapeAttribute } from '../xsd/xml-writer.js';
+/**
+ * Per-bundle cache of the built file set. Keyed by bundle identity, so a
+ * re-import (a new bundle object) rebuilds and the old entry is collected.
+ */
+const fileSetCache = new WeakMap();
+/** The `xmlns`/`xmlns:*` declarations in scope at `element` from its ancestors, nearest first. */
+function inheritedNamespaceDeclarations(element) {
+    const declarations = new Map();
+    let current = element.parentNode;
+    while (current !== null) {
+        if (current.nodeType === 1) {
+            const ancestor = current;
+            for (let index = 0; index < ancestor.attributes.length; index += 1) {
+                const attribute = ancestor.attributes.item(index);
+                if (attribute === null) {
+                    continue;
+                }
+                if ((attribute.name === 'xmlns' || attribute.name.startsWith('xmlns:')) && !declarations.has(attribute.name)) {
+                    declarations.set(attribute.name, attribute.value);
+                }
+            }
+        }
+        current = current.parentNode;
+    }
+    return declarations;
+}
+/** The `xs:import`/`xs:include`/`xs:redefine` elements of a schema, at any depth (they are top-level in practice). */
+function referenceElements(schema) {
+    return ['import', 'include', 'redefine'].flatMap((name) => childElements(schema, NS.XSD, name));
+}
+/** The index of the `>` that closes the (opening) tag starting at `text[0]`, skipping any `>`
+ * that appears inside a quoted attribute value (a raw `>` needs no escaping there, so it is
+ * legal — `indexOf('>')` would stop at the first one and truncate the tag). Returns `-1` when
+ * the tag never closes (should not happen for a serializer's own output). */
+function endOfStartTag(text) {
+    let quote;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (quote !== undefined) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === '>') {
+            return index;
+        }
+    }
+    return -1;
+}
+/**
+ * Clones `schema`, hoists the namespace declarations it inherited from its
+ * WSDL ancestors (prefixes used in `type="s:int"` attribute values would
+ * otherwise dangle), and rewrites every `schemaLocation` to the synthetic
+ * file name the referenced document was given.
+ */
+function synthesizeSchema(schema, base, fileNameFor) {
+    const clone = schema.cloneNode(true);
+    for (const reference of referenceElements(clone)) {
+        const location = reference.getAttribute('schemaLocation');
+        if (location === null || location === '') {
+            continue;
+        }
+        let resolved;
+        try {
+            resolved = new URL(location, base).toString();
+        }
+        catch {
+            resolved = location;
+        }
+        const fileName = fileNameFor.get(resolved);
+        if (fileName === undefined) {
+            // The bundle never resolved this reference; dropping the location leaves
+            // a namespace-only import, which libxml2 treats as "assume it is declared
+            // elsewhere" instead of failing to compile the whole set.
+            reference.removeAttribute('schemaLocation');
+            continue;
+        }
+        reference.setAttribute('schemaLocation', fileName);
+    }
+    // The namespace declarations are injected into the serialized text rather than
+    // set as attributes: xmldom's serializer emits a declaration for the element's
+    // own prefix by itself, and setting the same one as an attribute would produce
+    // a duplicate (which libxml2 rejects as not well formed).
+    const text = serializeXml(clone);
+    const insertAt = text.search(/[\s/>]/);
+    const tagEnd = endOfStartTag(text);
+    const head = text.slice(0, tagEnd === -1 ? text.length : tagEnd);
+    const extra = [...inheritedNamespaceDeclarations(schema)]
+        .filter(([name]) => !new RegExp(`[\\s<]${name.replace(':', '\\:')}\\s*=`).test(head))
+        .map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`)
+        .join('');
+    return `${text.slice(0, insertAt)}${extra}${text.slice(insertAt)}`;
+}
+/** Every `xs:schema` a bundled document contributes, with the document it came from. */
+function schemaElementsOf(document) {
+    const root = document.document.documentElement;
+    if (root === null) {
+        return [];
+    }
+    if (document.kind === 'xsd') {
+        return root.namespaceURI === NS.XSD && root.localName === 'schema' ? [root] : [];
+    }
+    const types = firstChildElement(root, NS.WSDL, 'types');
+    return types === undefined ? [] : childElements(types, NS.XSD, 'schema');
+}
+/** Builds (or returns the cached) libxml2 file set for `bundle`. */
+export function buildSchemaFileSet(bundle) {
+    const cached = fileSetCache.get(bundle);
+    if (cached !== undefined) {
+        return cached;
+    }
+    // Pass 1: name every document, so pass 2 can rewrite references to those names.
+    const fileNameFor = new Map();
+    const sources = [];
+    let index = 0;
+    for (const document of bundle.documents) {
+        const schemas = schemaElementsOf(document);
+        schemas.forEach((schema, ordinal) => {
+            index += 1;
+            const fileName = document.kind === 'wsdl' ? `embedded-${String(index)}.xsd` : `doc-${String(index)}.xsd`;
+            if (ordinal === 0) {
+                fileNameFor.set(document.location, fileName);
+                fileNameFor.set(document.requestedLocation, fileName);
+            }
+            sources.push({
+                schema,
+                base: document.location,
+                fileName,
+                chameleon: document.chameleonFor !== undefined,
+            });
+        });
+    }
+    // Pass 2: synthesize each schema, and group them by their own target namespace.
+    const files = [];
+    const byNamespace = new Map();
+    const noNamespace = [];
+    const documentOf = new Map();
+    for (const source of sources) {
+        files.push({ fileName: source.fileName, contents: synthesizeSchema(source.schema, source.base, fileNameFor) });
+        documentOf.set(source.fileName, source.base);
+        const targetNamespace = source.schema.getAttribute('targetNamespace');
+        if (targetNamespace === null || targetNamespace === '') {
+            // A chameleon include has no namespace of its own and is already pulled in
+            // by the schema that includes it; adding it again at the top level would
+            // redeclare its components.
+            if (!source.chameleon) {
+                noNamespace.push(source.fileName);
+            }
+            continue;
+        }
+        const bucket = byNamespace.get(targetNamespace);
+        if (bucket === undefined) {
+            byNamespace.set(targetNamespace, [source.fileName]);
+        }
+        else {
+            bucket.push(source.fileName);
+        }
+    }
+    // Pass 3: one glue schema per namespace, so a namespace split across several
+    // documents can still be imported by a wrapper with a single `xs:import`.
+    const glue = new Map();
+    let glueIndex = 0;
+    for (const [namespace, members] of byNamespace) {
+        glueIndex += 1;
+        const fileName = `ns-${String(glueIndex)}.xsd`;
+        const includes = members.map((member) => `  <xs:include schemaLocation="${escapeAttribute(member)}"/>`).join('\n');
+        files.push({
+            fileName,
+            contents: `<xs:schema xmlns:xs="${NS.XSD}" targetNamespace="${escapeAttribute(namespace)}">\n${includes}\n</xs:schema>`,
+        });
+        glue.set(namespace, fileName);
+    }
+    const fileSet = { files, glue, noNamespace, documentOf };
+    fileSetCache.set(bundle, fileSet);
+    return fileSet;
+}
+/** The `xs:import`/`xs:include` lines a wrapper needs to see every namespace but `own`. */
+function wrapperReferences(fileSet, own) {
+    const lines = [];
+    for (const [namespace, fileName] of fileSet.glue) {
+        lines.push(namespace === own
+            ? `  <xs:include schemaLocation="${escapeAttribute(fileName)}"/>`
+            : `  <xs:import namespace="${escapeAttribute(namespace)}" schemaLocation="${escapeAttribute(fileName)}"/>`);
+    }
+    for (const fileName of fileSet.noNamespace) {
+        lines.push(`  <xs:include schemaLocation="${escapeAttribute(fileName)}"/>`);
+    }
+    return lines.join('\n');
+}
+/** The wrapper schema for `document` style: no declarations of its own, just every namespace. */
+export function documentWrapper(fileSet) {
+    return `<xs:schema xmlns:xs="${NS.XSD}">\n${wrapperReferences(fileSet, undefined)}\n</xs:schema>`;
+}
+/**
+ * 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 function rpcWrapper(fileSet, namespace, elementName, binding) {
+    const prefixes = new Map([[NS.XSD, 'xs']]);
+    const prefixFor = (uri) => {
+        const existing = prefixes.get(uri);
+        if (existing !== undefined) {
+            return existing;
+        }
+        if (!fileSet.glue.has(uri)) {
+            return undefined;
+        }
+        const prefix = `p${String(prefixes.size)}`;
+        prefixes.set(uri, prefix);
+        return prefix;
+    };
+    const particles = binding.parts.map((part) => {
+        const name = escapeAttribute(part.name);
+        if (part.element !== undefined) {
+            const prefix = prefixFor(part.element.namespaceUri);
+            if (prefix !== undefined) {
+                return `    <xs:element ref="${prefix}:${escapeAttribute(part.element.localName)}"/>`;
+            }
+            return `    <xs:element name="${name}"/>`;
+        }
+        if (part.type !== undefined) {
+            const prefix = prefixFor(part.type.namespaceUri);
+            if (prefix !== undefined) {
+                return `    <xs:element name="${name}" type="${prefix}:${escapeAttribute(part.type.localName)}"/>`;
+            }
+        }
+        // An unknown part type must not fail the whole compile: accept anything.
+        return `    <xs:element name="${name}"/>`;
+    });
+    const declarations = [...prefixes].map(([uri, prefix]) => `xmlns:${prefix}="${escapeAttribute(uri)}"`).join(' ');
+    const content = particles.length === 0
+        ? '  <xs:complexType/>'
+        : `  <xs:complexType>\n   <xs:all>\n${particles.join('\n')}\n   </xs:all>\n  </xs:complexType>`;
+    return [
+        `<xs:schema ${declarations} targetNamespace="${escapeAttribute(namespace)}" elementFormDefault="unqualified">`,
+        wrapperReferences(fileSet, namespace),
+        ` <xs:element name="${escapeAttribute(elementName)}">`,
+        content,
+        ' </xs:element>',
+        '</xs:schema>',
+    ].join('\n');
+}
+/**
+ * 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 function fileSetLabels(fileSet) {
+    const labels = new Map();
+    for (const [fileName, location] of fileSet.documentOf) {
+        labels.set(fileName, location);
+    }
+    for (const fileName of fileSet.glue.values()) {
+        if (!labels.has(fileName)) {
+            labels.set(fileName, 'the schema set');
+        }
+    }
+    for (const fileName of fileSet.noNamespace) {
+        if (!labels.has(fileName)) {
+            labels.set(fileName, 'the schema set');
+        }
+    }
+    labels.set('wrapper.xsd', 'the schema set');
+    labels.set('body.xml', 'the message');
+    return labels;
+}

package/dist/validate/schema-validator.d.ts

@@ -0,0 +1,53 @@
+/**
+ * XSD validation of a SOAP message body against the interface's schema set,
+ * using libxml2 compiled to WebAssembly (`xmllint-wasm`).
+ *
+ * The envelope itself is never validated against the XSD — no schema in a
+ * WSDL describes `soapenv:Envelope` — so this module extracts each child of
+ * `Body` as its own little document and validates that. The extraction keeps
+ * the original source offsets: the fragment is padded with as many blank
+ * lines as precede it in the envelope, so every line number libxml2 reports
+ * is already a line number in the envelope the user is editing.
+ *
+ * `xmllint-wasm` runs libxml2 inside its own Node worker thread, so a
+ * validation never blocks the caller's event loop (measured: a 500 KB body
+ * validates in ~50 ms with a worst-case event-loop gap of ~6 ms). No extra
+ * worker of our own is needed; a wall-clock timeout guards against a
+ * pathological schema instead.
+ *
+ * Building the libxml2 file set itself — one synthetic file per schema
+ * document, the per-namespace glue files, and the `document`/`rpc` wrapper
+ * schemas — lives in `schema-file-set.ts`; this module only orchestrates
+ * validating one fragment against what that one builds.
+ */
+import type { DefinitionBundle } from '../wsdl/resolver.js';
+import type { SchemaSet } from '../xsd/schema-set.js';
+import type { ValidationBinding, ValidationProblem } from './types.js';
+/** Default wall-clock budget for one validation, in milliseconds. */
+export declare const DEFAULT_VALIDATION_TIMEOUT_MS = 10000;
+/** What the schema validator validates against: the compiled set plus the raw documents behind it. */
+export interface SchemaValidationTarget {
+    readonly schemaSet: SchemaSet;
+    readonly bundle: DefinitionBundle;
+}
+/** Options for {@link validateAgainstSchemaSet}. */
+export interface SchemaValidationOptions {
+    /** The operation being validated; required for `rpc` style, where no global element declares the body. */
+    readonly binding?: ValidationBinding;
+    /** Wall-clock budget for the whole validation; defaults to {@link DEFAULT_VALIDATION_TIMEOUT_MS}. */
+    readonly timeoutMs?: number;
+}
+/**
+ * Validates the `Body` children of a SOAP envelope against an interface's
+ * schema set with libxml2.
+ *
+ * Never throws: a message that cannot be tokenized, an empty body, or a schema
+ * set with no components all yield an empty list (the structure checks own
+ * those reports). Positions in the returned problems are lines in `xml`.
+ *
+ * @param xml the whole envelope text
+ * @param target the compiled schema set plus the bundle the raw schema documents come from
+ * @param options the binding context (required for `rpc` style) and the timeout
+ * @returns every schema finding, in body order
+ */
+export declare function validateAgainstSchemaSet(xml: string, target: SchemaValidationTarget, options?: SchemaValidationOptions): Promise<readonly ValidationProblem[]>;

package/dist/validate/schema-validator.js

@@ -0,0 +1,251 @@
+/**
+ * XSD validation of a SOAP message body against the interface's schema set,
+ * using libxml2 compiled to WebAssembly (`xmllint-wasm`).
+ *
+ * The envelope itself is never validated against the XSD — no schema in a
+ * WSDL describes `soapenv:Envelope` — so this module extracts each child of
+ * `Body` as its own little document and validates that. The extraction keeps
+ * the original source offsets: the fragment is padded with as many blank
+ * lines as precede it in the envelope, so every line number libxml2 reports
+ * is already a line number in the envelope the user is editing.
+ *
+ * `xmllint-wasm` runs libxml2 inside its own Node worker thread, so a
+ * validation never blocks the caller's event loop (measured: a 500 KB body
+ * validates in ~50 ms with a worst-case event-loop gap of ~6 ms). No extra
+ * worker of our own is needed; a wall-clock timeout guards against a
+ * pathological schema instead.
+ *
+ * Building the libxml2 file set itself — one synthetic file per schema
+ * document, the per-namespace glue files, and the `document`/`rpc` wrapper
+ * schemas — lives in `schema-file-set.ts`; this module only orchestrates
+ * validating one fragment against what that one builds.
+ */
+import { validateXML } from 'xmllint-wasm';
+import { localNameOf, tokenizeXml, buildRangeTree } from '../xml/tolerant-tree.js';
+import { escapeAttribute } from '../xsd/xml-writer.js';
+import { buildSchemaFileSet, documentWrapper, fileSetLabels, rpcWrapper } from './schema-file-set.js';
+/** Default wall-clock budget for one validation, in milliseconds. */
+export const DEFAULT_VALIDATION_TIMEOUT_MS = 10_000;
+/**
+ * Bundles whose most recent schema validation timed out and is still running in the background,
+ * mapped to the still-outstanding `validateXML` call. A new validation for the same bundle
+ * refuses to start a second libxml2 instance while one is stuck (minor 4 of the Task 42 fix
+ * round): a runaway schema would otherwise spawn one WASM instance per keystroke. The entry is
+ * removed as soon as the stale call finally settles, one way or the other.
+ */
+const staleByBundle = new WeakMap();
+/** The `xmlns`/`xmlns:*` declarations a range node carries, parsed out of its raw attribute text. */
+function declarationsOf(node) {
+    const declarations = new Map();
+    const pattern = /(xmlns(?::[\w.-]+)?)\s*=\s*"([^"]*)"|(xmlns(?::[\w.-]+)?)\s*=\s*'([^']*)'/g;
+    let match;
+    while ((match = pattern.exec(node.rawAttrs)) !== null) {
+        const name = match[1] ?? match[3];
+        const value = match[2] ?? match[4];
+        if (name !== undefined && value !== undefined) {
+            declarations.set(name, value);
+        }
+    }
+    return declarations;
+}
+/**
+ * Extracts every child element of `Body` as its own document. Returns an empty
+ * list when the envelope cannot be tokenized (a half-typed document): the
+ * structure checks already report that, and guessing here would only produce
+ * bogus markers.
+ */
+function bodyFragments(xml) {
+    const tokens = tokenizeXml(xml);
+    const roots = tokens === undefined ? undefined : buildRangeTree(tokens);
+    const envelope = roots?.find((node) => localNameOf(node.name) === 'Envelope');
+    const body = envelope?.children.find((node) => localNameOf(node.name) === 'Body');
+    if (envelope === undefined || body === undefined) {
+        return [];
+    }
+    // Namespace declarations the fragment inherits: envelope first, then Body,
+    // so a redeclaration on the inner element wins.
+    const inherited = new Map([...declarationsOf(envelope), ...declarationsOf(body)]);
+    return body.children.map((child) => {
+        const own = declarationsOf(child);
+        const extra = [...inherited]
+            .filter(([name]) => !own.has(name))
+            .map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`)
+            .join('');
+        const raw = xml.slice(child.start, child.end);
+        const insertAt = 1 + child.name.length;
+        const fragment = `${raw.slice(0, insertAt)}${extra}${raw.slice(insertAt)}`;
+        const line = xml.slice(0, child.start).split('\n').length;
+        const prefix = child.name.includes(':') ? child.name.slice(0, child.name.indexOf(':')) : '';
+        const namespaceUri = (prefix === '' ? inherited.get('xmlns') : inherited.get(`xmlns:${prefix}`)) ??
+            own.get(prefix === '' ? 'xmlns' : `xmlns:${prefix}`) ??
+            '';
+        const declared = own.get(prefix === '' ? 'xmlns' : `xmlns:${prefix}`);
+        return {
+            name: child.name,
+            namespaceUri: declared ?? namespaceUri,
+            // Blank-line padding keeps libxml2's line numbers aligned with the envelope.
+            contents: `${'\n'.repeat(line - 1)}${fragment}`,
+            line,
+        };
+    });
+}
+/** Strips libxml2's "Schemas validity error : " prefix from a message, and every synthetic file
+ * name the file set might mention (`labels`) with a name the user actually recognizes. */
+function cleanMessage(message, labels) {
+    let cleaned = message.replace(/^Schemas\s+\w+\s+(?:error|warning)\s*:\s*/i, '').trim();
+    for (const [fileName, label] of labels) {
+        if (cleaned.includes(fileName)) {
+            cleaned = cleaned.split(fileName).join(label);
+        }
+    }
+    return cleaned;
+}
+/** Runs `promise`, resolving to `fallback` when it takes longer than `ms`. */
+async function withTimeout(promise, ms, fallback) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timer = setTimeout(() => {
+                    resolve(fallback);
+                }, ms);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+}
+/** Validates one body fragment against `wrapper`, mapping libxml2's output to problems. */
+async function validateFragment(fragment, wrapper, fileSet, timeoutMs, bundle) {
+    const path = `/Envelope/Body/${fragment.name}`;
+    const labels = fileSetLabels(fileSet);
+    const timedOut = [
+        {
+            severity: 'warning',
+            code: 'schema-timeout',
+            message: `Schema validation of <${fragment.name}> timed out after ${String(timeoutMs)} ms`,
+            source: 'schema',
+            line: fragment.line,
+            path,
+        },
+    ];
+    const stale = staleByBundle.get(bundle);
+    if (stale !== undefined) {
+        // A previous validation for this interface is still stuck in libxml2; starting another one
+        // now would pile a second WASM instance on top of it. Refuse immediately, and let the stale
+        // call keep running in the background — see the `.then` below for when it clears.
+        return [
+            {
+                severity: 'warning',
+                code: 'schema-timeout',
+                message: `Schema validation of <${fragment.name}> was skipped: the interface's previous validation has not finished yet`,
+                source: 'schema',
+                line: fragment.line,
+                path,
+            },
+        ];
+    }
+    const call = validateXML({
+        xml: [{ fileName: 'body.xml', contents: fragment.contents }],
+        schema: [{ fileName: 'wrapper.xsd', contents: wrapper }],
+        preload: fileSet.files.map((file) => ({ fileName: file.fileName, contents: file.contents })),
+    });
+    let result;
+    try {
+        result = await withTimeout(call, timeoutMs, undefined);
+    }
+    catch (cause) {
+        // A schema set that does not compile is a problem with the definition, not
+        // with the message: report it once, as a warning, with no position.
+        return [
+            {
+                severity: 'warning',
+                code: 'schema-unavailable',
+                message: `The interface's schemas could not be compiled: ${cause instanceof Error ? cleanMessage(cause.message, labels) : String(cause)}`,
+                source: 'schema',
+            },
+        ];
+    }
+    if (result === undefined) {
+        // Timed out: track the still-running call so a second validation for this interface refuses
+        // to start another libxml2 instance until this one settles, one way or the other, and
+        // terminate the tracking (not the call itself — libxml2 gives us no handle for that) once
+        // it does.
+        staleByBundle.set(bundle, call);
+        call.then(() => {
+            if (staleByBundle.get(bundle) === call) {
+                staleByBundle.delete(bundle);
+            }
+        }, () => {
+            if (staleByBundle.get(bundle) === call) {
+                staleByBundle.delete(bundle);
+            }
+        });
+        return timedOut;
+    }
+    if (result.valid) {
+        return [];
+    }
+    return result.errors.flatMap((error) => {
+        const message = cleanMessage(error.message, labels);
+        const isBody = error.loc?.fileName === 'body.xml';
+        if (!isBody) {
+            // libxml2 warns when a namespace reachable through two files is imported
+            // twice — an artefact of the glue schemas, not a finding about the message.
+            if (/Schemas\s+\w+\s+warning\s*:/i.test(error.rawMessage)) {
+                return [];
+            }
+            return {
+                severity: 'warning',
+                code: 'schema-unavailable',
+                message,
+                source: 'schema',
+            };
+        }
+        return {
+            severity: 'error',
+            code: message.includes('No matching global declaration') ? 'schema-unknown-element' : 'schema-invalid',
+            message,
+            source: 'schema',
+            line: error.loc?.lineNumber ?? fragment.line,
+            path,
+        };
+    });
+}
+/**
+ * Validates the `Body` children of a SOAP envelope against an interface's
+ * schema set with libxml2.
+ *
+ * Never throws: a message that cannot be tokenized, an empty body, or a schema
+ * set with no components all yield an empty list (the structure checks own
+ * those reports). Positions in the returned problems are lines in `xml`.
+ *
+ * @param xml the whole envelope text
+ * @param target the compiled schema set plus the bundle the raw schema documents come from
+ * @param options the binding context (required for `rpc` style) and the timeout
+ * @returns every schema finding, in body order
+ */
+export async function validateAgainstSchemaSet(xml, target, options) {
+    if (target.schemaSet.elements.size === 0 && target.schemaSet.types.size === 0) {
+        return [];
+    }
+    const fragments = bodyFragments(xml);
+    if (fragments.length === 0) {
+        return [];
+    }
+    const fileSet = buildSchemaFileSet(target.bundle);
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_VALIDATION_TIMEOUT_MS;
+    const binding = options?.binding;
+    const problems = [];
+    for (const fragment of fragments) {
+        const wrapper = binding?.style === 'rpc'
+            ? rpcWrapper(fileSet, fragment.namespaceUri, localNameOf(fragment.name), binding)
+            : documentWrapper(fileSet);
+        problems.push(...(await validateFragment(fragment, wrapper, fileSet, timeoutMs, target.bundle)));
+    }
+    return problems;
+}

package/dist/validate/soap-structure.d.ts

@@ -0,0 +1,34 @@
+/**
+ * SOAP envelope structure checks — everything the XSD schema set cannot say
+ * about a message, because the envelope itself is never validated against it:
+ * the envelope namespace (and therefore the SOAP version), the
+ * `Header`/`Body` shape, the `Fault` shape, `mustUnderstand` values, and the
+ * agreement between the transport metadata (`Content-Type`, `SOAPAction`) and
+ * the version in the envelope.
+ *
+ * Tolerant by design: a document that is not well formed yields exactly one
+ * `xml-not-well-formed` problem (with the parser's position) instead of
+ * throwing, so a half-typed envelope still produces a usable marker.
+ */
+import type { SoapEnvelopeVersion } from '../soap/envelope.js';
+import type { ValidationProblem } from './types.js';
+/** What {@link checkSoapStructure} compares the message against. */
+export interface SoapStructureOptions {
+    /** The SOAP version the binding declares; an envelope in the other version's namespace is an error. */
+    readonly expectedVersion: SoapEnvelopeVersion;
+    /** The `SOAPAction` the request sends (1.1) or the action the binding declares (1.2). */
+    readonly soapAction?: string;
+    /** The `Content-Type` header the message is sent with (or was received with). */
+    readonly contentType?: string;
+}
+/**
+ * Checks the SOAP-level structure of `xml` against the binding's expectations.
+ *
+ * Never throws: a parse failure is reported as a single `xml-not-well-formed`
+ * problem carrying the parser's line/column.
+ *
+ * @param xml the whole envelope text, as typed in the editor
+ * @param options the binding's SOAP version, plus the transport metadata to cross-check
+ * @returns every finding, in document order (transport findings last)
+ */
+export declare function checkSoapStructure(xml: string, options: SoapStructureOptions): readonly ValidationProblem[];