@wirebench/engine 2.1.1

package/dist/validate/wsi/assertions/message/helpers.js

@@ -0,0 +1,168 @@
+/**
+ * Shared DOM and HTTP navigation for the message-level WS-I assertions.
+ *
+ * The message assertions look at the bytes that actually went on the wire, so they work on the
+ * parsed envelope plus the HTTP metadata rather than on any model: the profile constrains
+ * constructs (a `DOCTYPE`, a processing instruction, an attribute nobody models) that a parsed
+ * SOAP message would otherwise normalise away.
+ */
+import { NS } from '../../../../xml/namespaces.js';
+import { childElements, firstChildElement } from '../../../../wsdl/dom-utils.js';
+import { descendants, findingAt } from '../helpers.js';
+/** The envelope namespace a SOAP version uses. */
+export const SOAP_ENVELOPE_NS = {
+    '1.1': NS.SOAP11_ENV,
+    '1.2': NS.SOAP12_ENV,
+};
+/** The encoding namespace a SOAP version uses. */
+export const SOAP_ENCODING_NS = {
+    '1.1': NS.SOAP11_ENC,
+    '1.2': NS.SOAP12_ENC,
+};
+/** Every message half that actually parsed into a `soap:Envelope`. */
+export function envelopes(context) {
+    return context.messages.filter((view) => view.envelope !== undefined && view.soapNs !== undefined);
+}
+/** Builds a finding pointing at `element`, attributed to the half it was found in. */
+export function messageFinding(view, element, message) {
+    return findingAt(view.direction, element, message);
+}
+/** Builds a finding about a half as a whole (an HTTP header, a missing envelope). */
+export function viewFinding(view, message) {
+    return { message, location: { document: view.direction } };
+}
+/** The envelope element and every element beneath it, in document order. */
+export function envelopeElements(view) {
+    const envelope = view.envelope;
+    return envelope === undefined ? [] : [envelope, ...descendants(envelope)];
+}
+/** The element children of `parent`, in document order (whatever their namespace). */
+export function elementChildren(parent) {
+    const out = [];
+    let child = parent.firstChild;
+    while (child !== null) {
+        if (child.nodeType === 1) {
+            out.push(child);
+        }
+        child = child.nextSibling;
+    }
+    return out;
+}
+/** The element children of `soap:Envelope`, in document order (whatever their namespace). */
+export function envelopeChildren(view) {
+    const envelope = view.envelope;
+    return envelope === undefined ? [] : elementChildren(envelope);
+}
+/** The `soap:Body` of a half, when it has exactly the one the profile requires. */
+export function bodyOf(view) {
+    const envelope = view.envelope;
+    return envelope === undefined || view.soapNs === undefined
+        ? undefined
+        : firstChildElement(envelope, view.soapNs, 'Body');
+}
+/** The `soap:Header` of a half, when it declares one. */
+export function headerOf(view) {
+    const envelope = view.envelope;
+    return envelope === undefined || view.soapNs === undefined
+        ? undefined
+        : firstChildElement(envelope, view.soapNs, 'Header');
+}
+/** The `soap:Fault` carried directly by `soap:Body`, when the half is a fault. */
+export function faultOf(view) {
+    const body = bodyOf(view);
+    return body === undefined || view.soapNs === undefined ? undefined : firstChildElement(body, view.soapNs, 'Fault');
+}
+/** The element children of `soap:Body`, in document order. */
+export function bodyChildren(view) {
+    const body = bodyOf(view);
+    return body === undefined ? [] : elementChildren(body);
+}
+/** Every attribute of `element`, as a plain list (xmldom's `attributes` is a live NamedNodeMap). */
+export function attributesOf(element) {
+    const out = [];
+    const attributes = element.attributes;
+    for (let index = 0; index < attributes.length; index += 1) {
+        const attribute = attributes.item(index);
+        if (attribute !== null) {
+            out.push({
+                name: attribute.name,
+                localName: attribute.localName ?? attribute.name,
+                namespaceUri: attribute.namespaceURI,
+                value: attribute.value,
+            });
+        }
+    }
+    return out;
+}
+/** The media type of a `Content-Type` value, lower-cased and stripped of its parameters. */
+export function mediaTypeOf(contentType) {
+    return (contentType.split(';')[0] ?? '').trim().toLowerCase();
+}
+/** The `charset` parameter of a `Content-Type` value, when it states one. */
+export function charsetOf(contentType) {
+    const match = /;\s*charset\s*=\s*"?([^";]+)"?/i.exec(contentType);
+    return match?.[1]?.trim();
+}
+/** One header of a half, by its (already lower-cased) name. */
+export function headerValue(view, name) {
+    return view.headers[name];
+}
+/** The prefixes in scope on `element`, mapped to the namespace they are bound to. */
+export function inScopePrefixes(element) {
+    const prefixes = new Map();
+    let current = element;
+    while (current !== null && current.nodeType === 1) {
+        for (const attribute of attributesOf(current)) {
+            if (attribute.name === 'xmlns' && !prefixes.has('')) {
+                prefixes.set('', attribute.value);
+            }
+            else if (attribute.name.startsWith('xmlns:') && !prefixes.has(attribute.localName)) {
+                prefixes.set(attribute.localName, attribute.value);
+            }
+        }
+        const parent = current.parentNode;
+        current = parent !== null && parent.nodeType === 1 ? parent : null;
+    }
+    return prefixes;
+}
+/**
+ * The first unqualified child element of `parent` with this local name. SOAP 1.1 declares the
+ * fault's children in no namespace, and xmldom reports that as a `null` `namespaceURI`, which
+ * `childElements(parent, '', name)` does not match.
+ */
+export function unqualifiedChild(parent, localName) {
+    let child = parent.firstChild;
+    while (child !== null) {
+        if (child.nodeType === 1) {
+            const element = child;
+            const ns = element.namespaceURI;
+            if ((ns === null || ns === '') && element.localName === localName) {
+                return element;
+            }
+        }
+        child = child.nextSibling;
+    }
+    return undefined;
+}
+/** Every `soap:Header` block (its element children), in document order. */
+export function headerBlocks(view) {
+    const header = headerOf(view);
+    return header === undefined ? [] : elementChildren(header);
+}
+/** The `soap:Body` children of a half, skipping the `soap:Fault` (which has its own rules). */
+export function partAccessors(view) {
+    const fault = faultOf(view);
+    return bodyChildren(view).filter((child) => child !== fault);
+}
+/** The number of `soap:Body` elements directly under `soap:Envelope`. */
+export function bodyCount(view) {
+    const envelope = view.envelope;
+    return envelope === undefined || view.soapNs === undefined ? 0 : childElements(envelope, view.soapNs, 'Body').length;
+}
+/** The number of `soap:Header` elements directly under `soap:Envelope`. */
+export function headerCount(view) {
+    const envelope = view.envelope;
+    return envelope === undefined || view.soapNs === undefined
+        ? 0
+        : childElements(envelope, view.soapNs, 'Header').length;
+}

package/dist/validate/wsi/assertions/message/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The WS-I Basic Profile 1.1 message assertion catalogue.
+ *
+ * The description-level counterpart lives in `../index.ts`. This array is the single source of
+ * truth for `runMessageAssertions` and for the message table `scripts/wsi-docs.ts` generates;
+ * adding an assertion means adding a module here and nothing else.
+ *
+ * R1007, R1011 and R1003 overlap by design: R1007 constrains *what* may be a child of
+ * `soap:Envelope`, R1011 constrains *where* (nothing may follow `soap:Body`), and R1003 folds
+ * both into the profile's cardinality/order rule for `soap:Body`/`soap:Header`. A single
+ * malformed envelope can therefore fail all three; that is expected, not a bug.
+ */
+import type { WsiMessageAssertion } from '../../types.js';
+import { R1001 } from './r1001.js';
+import { R1003 } from './r1003.js';
+import { R1005 } from './r1005.js';
+import { R1006 } from './r1006.js';
+import { R1007 } from './r1007.js';
+import { R1011 } from './r1011.js';
+import { R1012 } from './r1012.js';
+import { R1013 } from './r1013.js';
+import { R1014 } from './r1014.js';
+import { R1015 } from './r1015.js';
+import { R1017 } from './r1017.js';
+import { R1100 } from './r1100.js';
+import { R1101 } from './r1101.js';
+import { R1102 } from './r1102.js';
+import { R1103 } from './r1103.js';
+import { R1107 } from './r1107.js';
+import { R1109 } from './r1109.js';
+import { R1124 } from './r1124.js';
+import { R1132 } from './r1132.js';
+import { R1140 } from './r1140.js';
+import { R1141 } from './r1141.js';
+import { R2113 } from './r2113.js';
+import { R2211 } from './r2211.js';
+/** Every implemented message assertion, in profile id order. */
+export declare const WSI_MESSAGE_ASSERTIONS: readonly WsiMessageAssertion[];
+export { R1001, R1003, R1005, R1006, R1007, R1011, R1012, R1013, R1014, R1015, R1017, R1100, R1101, R1102, R1103, R1107, R1109, R1124, R1132, R1140, R1141, R2113, R2211, };

package/dist/validate/wsi/assertions/message/index.js

@@ -0,0 +1,62 @@
+/**
+ * The WS-I Basic Profile 1.1 message assertion catalogue.
+ *
+ * The description-level counterpart lives in `../index.ts`. This array is the single source of
+ * truth for `runMessageAssertions` and for the message table `scripts/wsi-docs.ts` generates;
+ * adding an assertion means adding a module here and nothing else.
+ *
+ * R1007, R1011 and R1003 overlap by design: R1007 constrains *what* may be a child of
+ * `soap:Envelope`, R1011 constrains *where* (nothing may follow `soap:Body`), and R1003 folds
+ * both into the profile's cardinality/order rule for `soap:Body`/`soap:Header`. A single
+ * malformed envelope can therefore fail all three; that is expected, not a bug.
+ */
+import { R1001 } from './r1001.js';
+import { R1003 } from './r1003.js';
+import { R1005 } from './r1005.js';
+import { R1006 } from './r1006.js';
+import { R1007 } from './r1007.js';
+import { R1011 } from './r1011.js';
+import { R1012 } from './r1012.js';
+import { R1013 } from './r1013.js';
+import { R1014 } from './r1014.js';
+import { R1015 } from './r1015.js';
+import { R1017 } from './r1017.js';
+import { R1100 } from './r1100.js';
+import { R1101 } from './r1101.js';
+import { R1102 } from './r1102.js';
+import { R1103 } from './r1103.js';
+import { R1107 } from './r1107.js';
+import { R1109 } from './r1109.js';
+import { R1124 } from './r1124.js';
+import { R1132 } from './r1132.js';
+import { R1140 } from './r1140.js';
+import { R1141 } from './r1141.js';
+import { R2113 } from './r2113.js';
+import { R2211 } from './r2211.js';
+/** Every implemented message assertion, in profile id order. */
+export const WSI_MESSAGE_ASSERTIONS = Object.freeze([
+    R1001,
+    R1003,
+    R1005,
+    R1006,
+    R1007,
+    R1011,
+    R1012,
+    R1013,
+    R1014,
+    R1015,
+    R1017,
+    R1100,
+    R1101,
+    R1102,
+    R1103,
+    R1107,
+    R1109,
+    R1124,
+    R1132,
+    R1140,
+    R1141,
+    R2113,
+    R2211,
+]);
+export { R1001, R1003, R1005, R1006, R1007, R1011, R1012, R1013, R1014, R1015, R1017, R1100, R1101, R1102, R1103, R1107, R1109, R1124, R1132, R1140, R1141, R2113, R2211, };

package/dist/validate/wsi/assertions/message/r1001.d.ts

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1001: a message must be a SOAP envelope — well-formed XML whose document element is
+ * `soap:Envelope` in the envelope namespace of the version the binding declares. An HTML error
+ * page, a bare body, or a SOAP 1.2 envelope answering a SOAP 1.1 binding all breach it.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export declare const R1001: WsiMessageAssertion;

package/dist/validate/wsi/assertions/message/r1001.js

@@ -0,0 +1,38 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { SOAP_ENVELOPE_NS, viewFinding } from './helpers.js';
+/**
+ * BP 1.1 R1001: a message must be a SOAP envelope — well-formed XML whose document element is
+ * `soap:Envelope` in the envelope namespace of the version the binding declares. An HTML error
+ * page, a bare body, or a SOAP 1.2 envelope answering a SOAP 1.1 binding all breach it.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export const R1001 = {
+    id: 'R1001',
+    title: 'Each message is a soap:Envelope of the SOAP version the binding declares',
+    level: 'REQUIRED',
+    section: '3.1 XML Representation of SOAP Messages',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        let envelopes = 0;
+        const expected = SOAP_ENVELOPE_NS[context.binding.soapVersion];
+        for (const view of context.messages) {
+            if (view.envelopeXml === undefined) {
+                continue;
+            }
+            envelopes += 1;
+            if (view.document === undefined) {
+                findings.push(viewFinding(view, `the ${view.direction} is not well-formed XML, so it is not a SOAP envelope`));
+            }
+            else if (view.envelope === undefined) {
+                findings.push(viewFinding(view, `the ${view.direction} document element is "${view.document.documentElement?.nodeName ?? '(none)'}", not soap:Envelope`));
+            }
+            else if (view.soapNs !== expected) {
+                findings.push(viewFinding(view, `the ${view.direction} envelope is in "${view.soapNs ?? ''}"; the binding declares SOAP ${context.binding.soapVersion} ("${expected}")`));
+            }
+        }
+        return envelopes === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/message/r1003.d.ts

@@ -0,0 +1,14 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1003: an envelope carries exactly one `soap:Body`, at most one `soap:Header`, and the
+ * header — when there is one — comes first. Anything else is not the structure SOAP 1.1 section 4
+ * defines, so a receiver's dispatch is undefined.
+ *
+ * This is the best-attributed id Wirebench could give the requirement: it and R1012 (the
+ * UTF-8/UTF-16 serialization rule) were previously swapped; see the module doc for the note on
+ * the structural overlap with R1007/R1011.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export declare const R1003: WsiMessageAssertion;

package/dist/validate/wsi/assertions/message/r1003.js

@@ -0,0 +1,45 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { bodyCount, envelopeChildren, envelopes, headerCount, messageFinding, viewFinding } from './helpers.js';
+/**
+ * BP 1.1 R1003: an envelope carries exactly one `soap:Body`, at most one `soap:Header`, and the
+ * header — when there is one — comes first. Anything else is not the structure SOAP 1.1 section 4
+ * defines, so a receiver's dispatch is undefined.
+ *
+ * This is the best-attributed id Wirebench could give the requirement: it and R1012 (the
+ * UTF-8/UTF-16 serialization rule) were previously swapped; see the module doc for the note on
+ * the structural overlap with R1007/R1011.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export const R1003 = {
+    id: 'R1003',
+    title: 'An envelope carries one soap:Body, at most one soap:Header, header first',
+    level: 'REQUIRED',
+    section: '3.1 XML Representation of SOAP Messages',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        const views = envelopes(context);
+        for (const view of views) {
+            const bodies = bodyCount(view);
+            const headers = headerCount(view);
+            if (bodies !== 1) {
+                findings.push(viewFinding(view, `the ${view.direction} envelope carries ${bodies} soap:Body elements; exactly one is required`));
+            }
+            if (headers > 1) {
+                findings.push(viewFinding(view, `the ${view.direction} envelope carries ${headers} soap:Header elements; at most one is allowed`));
+            }
+            const children = envelopeChildren(view);
+            const bodyIndex = children.findIndex((child) => child.namespaceURI === view.soapNs && child.localName === 'Body');
+            const headerIndex = children.findIndex((child) => child.namespaceURI === view.soapNs && child.localName === 'Header');
+            if (headerIndex > -1 && bodyIndex > -1 && headerIndex > bodyIndex) {
+                const header = children[headerIndex];
+                if (header !== undefined) {
+                    findings.push(messageFinding(view, header, 'soap:Header follows soap:Body; it must precede it'));
+                }
+            }
+        }
+        return views.length === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/message/r1005.d.ts

@@ -0,0 +1,12 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1005: a message must not contain a Document Type Declaration. A `DOCTYPE` lets a
+ * message pull in external entities, which a receiver cannot be expected to resolve.
+ *
+ * The check works on the raw text rather than the DOM: a parser is free to drop the declaration
+ * once it has applied it, so by the time there is a document the evidence may be gone.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export declare const R1005: WsiMessageAssertion;

package/dist/validate/wsi/assertions/message/r1005.js

@@ -0,0 +1,37 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { viewFinding } from './helpers.js';
+/**
+ * BP 1.1 R1005: a message must not contain a Document Type Declaration. A `DOCTYPE` lets a
+ * message pull in external entities, which a receiver cannot be expected to resolve.
+ *
+ * The check works on the raw text rather than the DOM: a parser is free to drop the declaration
+ * once it has applied it, so by the time there is a document the evidence may be gone.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export const R1005 = {
+    id: 'R1005',
+    title: 'A message contains no Document Type Declaration',
+    level: 'REQUIRED',
+    section: '3.1 XML Representation of SOAP Messages',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        let messages = 0;
+        for (const view of context.messages) {
+            if (view.envelopeXml === undefined) {
+                continue;
+            }
+            messages += 1;
+            // Anything before the document element is prolog; a DOCTYPE can only legally appear there.
+            const rootTag = '<' + (view.document?.documentElement?.nodeName ?? '\u0000');
+            const rootIndex = view.envelopeXml.indexOf(rootTag);
+            const prolog = rootIndex === -1 ? view.envelopeXml : view.envelopeXml.slice(0, rootIndex);
+            if (/<!DOCTYPE\b/i.test(prolog)) {
+                findings.push(viewFinding(view, `the ${view.direction} carries a Document Type Declaration`));
+            }
+        }
+        return messages === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/message/r1006.d.ts

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1006: a message must not contain processing instructions. Their meaning is defined by
+ * the application, not the profile, so a receiver has no interoperable way to act on one. The XML
+ * declaration is not a processing instruction and is not reported.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export declare const R1006: WsiMessageAssertion;

package/dist/validate/wsi/assertions/message/r1006.js

@@ -0,0 +1,49 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { viewFinding } from './helpers.js';
+/** Counts the processing instructions anywhere in a parsed document. */
+function processingInstructions(root) {
+    const found = [];
+    const visit = (node) => {
+        let child = node.firstChild;
+        while (child !== null) {
+            // xmldom exposes the XML declaration as a processing instruction named `xml`; it is a
+            // declaration, not an instruction, and the profile does not forbid it.
+            if (child.nodeType === 7 && child.nodeName !== 'xml') {
+                found.push(child.nodeName);
+            }
+            visit(child);
+            child = child.nextSibling;
+        }
+    };
+    visit(root);
+    return found;
+}
+/**
+ * BP 1.1 R1006: a message must not contain processing instructions. Their meaning is defined by
+ * the application, not the profile, so a receiver has no interoperable way to act on one. The XML
+ * declaration is not a processing instruction and is not reported.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export const R1006 = {
+    id: 'R1006',
+    title: 'A message contains no processing instructions',
+    level: 'REQUIRED',
+    section: '3.1 XML Representation of SOAP Messages',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        let documents = 0;
+        for (const view of context.messages) {
+            if (view.document === undefined) {
+                continue;
+            }
+            documents += 1;
+            for (const name of processingInstructions(view.document)) {
+                findings.push(viewFinding(view, `the ${view.direction} carries the processing instruction "<?${name} ... ?>"`));
+            }
+        }
+        return documents === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/message/r1007.d.ts

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1007: `soap:Envelope` has no element children other than `soap:Header` and
+ * `soap:Body`. A trailing signature or a stray application element there is invisible to a
+ * conforming receiver, which only ever looks in the two.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export declare const R1007: WsiMessageAssertion;

package/dist/validate/wsi/assertions/message/r1007.js

@@ -0,0 +1,30 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { envelopeChildren, envelopes, messageFinding } from './helpers.js';
+/**
+ * BP 1.1 R1007: `soap:Envelope` has no element children other than `soap:Header` and
+ * `soap:Body`. A trailing signature or a stray application element there is invisible to a
+ * conforming receiver, which only ever looks in the two.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export const R1007 = {
+    id: 'R1007',
+    title: 'soap:Envelope has no element children other than soap:Header and soap:Body',
+    level: 'REQUIRED',
+    section: '3.1 XML Representation of SOAP Messages',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        const views = envelopes(context);
+        for (const view of views) {
+            for (const child of envelopeChildren(view)) {
+                const known = child.namespaceURI === view.soapNs && (child.localName === 'Header' || child.localName === 'Body');
+                if (!known) {
+                    findings.push(messageFinding(view, child, `soap:Envelope has the unexpected element child "${child.nodeName}"`));
+                }
+            }
+        }
+        return views.length === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/message/r1011.d.ts

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1011: nothing follows `soap:Body`. A receiver may stop reading once the body has been
+ * dispatched, so an element after it is not reliably seen. R1007 constrains *what* may appear as
+ * an envelope child; this one constrains *where*.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export declare const R1011: WsiMessageAssertion;

package/dist/validate/wsi/assertions/message/r1011.js

@@ -0,0 +1,33 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { envelopeChildren, envelopes, messageFinding } from './helpers.js';
+/**
+ * BP 1.1 R1011: nothing follows `soap:Body`. A receiver may stop reading once the body has been
+ * dispatched, so an element after it is not reliably seen. R1007 constrains *what* may appear as
+ * an envelope child; this one constrains *where*.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export const R1011 = {
+    id: 'R1011',
+    title: 'No element child of soap:Envelope follows soap:Body',
+    level: 'REQUIRED',
+    section: '3.1 XML Representation of SOAP Messages',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        let bodies = 0;
+        for (const view of envelopes(context)) {
+            const children = envelopeChildren(view);
+            const bodyIndex = children.findIndex((child) => child.namespaceURI === view.soapNs && child.localName === 'Body');
+            if (bodyIndex === -1) {
+                continue;
+            }
+            bodies += 1;
+            for (const trailing of children.slice(bodyIndex + 1)) {
+                findings.push(messageFinding(view, trailing, `"${trailing.nodeName}" follows soap:Body inside soap:Envelope`));
+            }
+        }
+        return bodies === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/message/r1012.d.ts

@@ -0,0 +1,13 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1012: a message is serialized as UTF-8 or UTF-16. Only a message that states its
+ * encoding in an XML declaration can be judged here; one that states none is, by the XML rules,
+ * already UTF-8 or UTF-16 and so conforms.
+ *
+ * This is the best-attributed id Wirebench could give the requirement: it and R1003 (the
+ * envelope-structure rule) were previously swapped.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export declare const R1012: WsiMessageAssertion;

package/dist/validate/wsi/assertions/message/r1012.js

@@ -0,0 +1,37 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { viewFinding } from './helpers.js';
+/** The encodings the profile allows a message to be serialized in. */
+const ALLOWED = ['utf-8', 'utf-16'];
+/**
+ * BP 1.1 R1012: a message is serialized as UTF-8 or UTF-16. Only a message that states its
+ * encoding in an XML declaration can be judged here; one that states none is, by the XML rules,
+ * already UTF-8 or UTF-16 and so conforms.
+ *
+ * This is the best-attributed id Wirebench could give the requirement: it and R1003 (the
+ * envelope-structure rule) were previously swapped.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export const R1012 = {
+    id: 'R1012',
+    title: 'A message that declares an encoding declares UTF-8 or UTF-16',
+    level: 'REQUIRED',
+    section: '3.1 XML Representation of SOAP Messages',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        let declarations = 0;
+        for (const view of context.messages) {
+            const declared = /^\s*<\?xml[^?]*encoding\s*=\s*["']([^"']+)["']/i.exec(view.envelopeXml ?? '')?.[1];
+            if (declared === undefined) {
+                continue;
+            }
+            declarations += 1;
+            if (!ALLOWED.includes(declared.toLowerCase())) {
+                findings.push(viewFinding(view, `the ${view.direction} declares encoding "${declared}"; the profile allows UTF-8 and UTF-16`));
+            }
+        }
+        return declarations === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/message/r1013.d.ts

@@ -0,0 +1,9 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1013: `soap:mustUnderstand` carries a value the SOAP version admits. A receiver that
+ * cannot parse the flag cannot tell a header block it may ignore from one it must reject.
+ *
+ * The id is a paraphrase of the requirement Wirebench implements; it could not be confirmed
+ * against the published profile, so the catalogue marks it unverified.
+ */
+export declare const R1013: WsiMessageAssertion;