@wirebench/engine 2.1.1

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

@@ -0,0 +1,42 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { attributesOf, envelopeElements, envelopes, messageFinding } from './helpers.js';
+/** The `soap:mustUnderstand` values each SOAP version admits. */
+const ALLOWED = {
+    // SOAP 1.1 types the attribute as xsd:boolean restricted to the two digits.
+    '1.1': ['0', '1'],
+    // SOAP 1.2 types it as a plain xsd:boolean, so the lexical forms of true/false are all legal.
+    '1.2': ['0', '1', 'true', 'false'],
+};
+/**
+ * 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 const R1013 = {
+    id: 'R1013',
+    title: 'soap:mustUnderstand carries a value the SOAP version admits',
+    level: 'REQUIRED',
+    section: '3.2 SOAP Processing Model',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        let attributes = 0;
+        const allowed = ALLOWED[context.binding.soapVersion];
+        for (const view of envelopes(context)) {
+            for (const element of envelopeElements(view)) {
+                for (const attribute of attributesOf(element)) {
+                    if (attribute.namespaceUri !== view.soapNs || attribute.localName !== 'mustUnderstand') {
+                        continue;
+                    }
+                    attributes += 1;
+                    if (!allowed.includes(attribute.value)) {
+                        findings.push(messageFinding(view, element, `soap:mustUnderstand="${attribute.value}" on "${element.nodeName}"; SOAP ${context.binding.soapVersion} allows ${allowed.join(', ')}`));
+                    }
+                }
+            }
+        }
+        return attributes === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1014: the children of `soap:Body` are namespace-qualified. The body child is what a
+ * receiver dispatches on, and an unqualified name cannot be matched against a global element
+ * declaration or an rpc operation wrapper.
+ *
+ * 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 R1014: WsiMessageAssertion;

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

@@ -0,0 +1,30 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { bodyChildren, envelopes, messageFinding } from './helpers.js';
+/**
+ * BP 1.1 R1014: the children of `soap:Body` are namespace-qualified. The body child is what a
+ * receiver dispatches on, and an unqualified name cannot be matched against a global element
+ * declaration or an rpc operation wrapper.
+ *
+ * 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 R1014 = {
+    id: 'R1014',
+    title: 'The children of soap:Body are namespace-qualified',
+    level: 'REQUIRED',
+    section: '3.1 XML Representation of SOAP Messages',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        let children = 0;
+        for (const view of envelopes(context)) {
+            for (const child of bodyChildren(view)) {
+                children += 1;
+                if (child.namespaceURI === null || child.namespaceURI === '') {
+                    findings.push(messageFinding(view, child, `the soap:Body child "${child.nodeName}" is not namespace-qualified`));
+                }
+            }
+        }
+        return children === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,12 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1015: a message bound with `use="literal"` carries no `soap:encodingStyle` attribute.
+ * A literal body is an instance of a schema, not a graph serialization, so naming an encoding for
+ * it is meaningless — and a receiver that honoured it would read the body differently.
+ *
+ * Not applicable to an `encoded` binding, where naming the encoding is exactly the point.
+ *
+ * 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 R1015: WsiMessageAssertion;

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

@@ -0,0 +1,36 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { attributesOf, envelopeElements, envelopes, messageFinding } from './helpers.js';
+/**
+ * BP 1.1 R1015: a message bound with `use="literal"` carries no `soap:encodingStyle` attribute.
+ * A literal body is an instance of a schema, not a graph serialization, so naming an encoding for
+ * it is meaningless — and a receiver that honoured it would read the body differently.
+ *
+ * Not applicable to an `encoded` binding, where naming the encoding is exactly the point.
+ *
+ * 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 R1015 = {
+    id: 'R1015',
+    title: 'A literal message carries no soap:encodingStyle attribute',
+    level: 'REQUIRED',
+    section: '3.1 XML Representation of SOAP Messages',
+    unverifiedId: true,
+    check(context) {
+        if (context.binding.use !== 'literal') {
+            return NOT_APPLICABLE;
+        }
+        const findings = [];
+        const views = envelopes(context);
+        for (const view of views) {
+            for (const element of envelopeElements(view)) {
+                for (const attribute of attributesOf(element)) {
+                    if (attribute.namespaceUri === view.soapNs && attribute.localName === 'encodingStyle') {
+                        findings.push(messageFinding(view, element, `"${element.nodeName}" carries soap:encodingStyle="${attribute.value}" in a ${context.binding.style}/literal message`));
+                    }
+                }
+            }
+        }
+        return views.length === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1017: every `soap:Header` block is namespace-qualified. A header block is addressed by
+ * its qualified name; an unqualified one belongs to no module and cannot be targeted by a
+ * `mustUnderstand` contract.
+ *
+ * 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 R1017: WsiMessageAssertion;

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

@@ -0,0 +1,30 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { envelopes, headerBlocks, messageFinding } from './helpers.js';
+/**
+ * BP 1.1 R1017: every `soap:Header` block is namespace-qualified. A header block is addressed by
+ * its qualified name; an unqualified one belongs to no module and cannot be targeted by a
+ * `mustUnderstand` contract.
+ *
+ * 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 R1017 = {
+    id: 'R1017',
+    title: 'Every soap:Header block is namespace-qualified',
+    level: 'REQUIRED',
+    section: '3.2 SOAP Processing Model',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        let blocks = 0;
+        for (const view of envelopes(context)) {
+            for (const block of headerBlocks(view)) {
+                blocks += 1;
+                if (block.namespaceURI === null || block.namespaceURI === '') {
+                    findings.push(messageFinding(view, block, `the soap:Header block "${block.nodeName}" is not namespace-qualified`));
+                }
+            }
+        }
+        return blocks === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1100: a SOAP 1.1 `soap:Fault` has no element children other than `faultcode`,
+ * `faultstring`, `faultactor` and `detail`. Application data belongs inside `detail`, where a
+ * receiver knows to look for 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 R1100: WsiMessageAssertion;

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

@@ -0,0 +1,39 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { elementChildren, envelopes, faultOf, messageFinding } from './helpers.js';
+/** The only children SOAP 1.1 defines for `soap:Fault`. */
+const FAULT_CHILDREN = ['faultcode', 'faultstring', 'faultactor', 'detail'];
+/**
+ * BP 1.1 R1100: a SOAP 1.1 `soap:Fault` has no element children other than `faultcode`,
+ * `faultstring`, `faultactor` and `detail`. Application data belongs inside `detail`, where a
+ * receiver knows to look for 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 R1100 = {
+    id: 'R1100',
+    title: 'soap:Fault has only the four children SOAP 1.1 defines',
+    level: 'REQUIRED',
+    section: '3.5 SOAP Faults',
+    unverifiedId: true,
+    check(context) {
+        if (context.binding.soapVersion !== '1.1') {
+            return NOT_APPLICABLE;
+        }
+        const findings = [];
+        let faults = 0;
+        for (const view of envelopes(context)) {
+            const fault = faultOf(view);
+            if (fault === undefined) {
+                continue;
+            }
+            faults += 1;
+            for (const child of elementChildren(fault)) {
+                if (!FAULT_CHILDREN.includes(child.localName ?? child.nodeName)) {
+                    findings.push(messageFinding(view, child, `soap:Fault has the unexpected child "${child.nodeName}"`));
+                }
+            }
+        }
+        return faults === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1101: the children of a SOAP 1.1 `soap:Fault` are unqualified. SOAP 1.1 declares
+ * `faultcode`, `faultstring`, `faultactor` and `detail` with no target namespace, so putting them
+ * in the envelope namespace (a common mistake) produces names a receiver does not recognise.
+ *
+ * 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 R1101: WsiMessageAssertion;

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

@@ -0,0 +1,37 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { elementChildren, envelopes, faultOf, messageFinding } from './helpers.js';
+/**
+ * BP 1.1 R1101: the children of a SOAP 1.1 `soap:Fault` are unqualified. SOAP 1.1 declares
+ * `faultcode`, `faultstring`, `faultactor` and `detail` with no target namespace, so putting them
+ * in the envelope namespace (a common mistake) produces names a receiver does not recognise.
+ *
+ * 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 R1101 = {
+    id: 'R1101',
+    title: 'The children of a SOAP 1.1 soap:Fault are unqualified',
+    level: 'REQUIRED',
+    section: '3.5 SOAP Faults',
+    unverifiedId: true,
+    check(context) {
+        if (context.binding.soapVersion !== '1.1') {
+            return NOT_APPLICABLE;
+        }
+        const findings = [];
+        let children = 0;
+        for (const view of envelopes(context)) {
+            const fault = faultOf(view);
+            if (fault === undefined) {
+                continue;
+            }
+            for (const child of elementChildren(fault)) {
+                children += 1;
+                if (child.namespaceURI !== null && child.namespaceURI !== '') {
+                    findings.push(messageFinding(view, child, `the soap:Fault child "${child.nodeName}" is qualified ("${child.namespaceURI}"); it must be unqualified`));
+                }
+            }
+        }
+        return children === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1102: a `faultcode` carries a QName whose prefix is declared in scope. An undeclared
+ * prefix makes the code unresolvable, and a receiver cannot tell a `Client` fault (do not retry)
+ * from a `Server` one (retry may help).
+ *
+ * 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 R1102: WsiMessageAssertion;

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

@@ -0,0 +1,41 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { envelopes, faultOf, inScopePrefixes, messageFinding, unqualifiedChild } from './helpers.js';
+/**
+ * BP 1.1 R1102: a `faultcode` carries a QName whose prefix is declared in scope. An undeclared
+ * prefix makes the code unresolvable, and a receiver cannot tell a `Client` fault (do not retry)
+ * from a `Server` one (retry may help).
+ *
+ * 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 R1102 = {
+    id: 'R1102',
+    title: 'A faultcode is a QName whose prefix is declared in scope',
+    level: 'REQUIRED',
+    section: '3.5 SOAP Faults',
+    unverifiedId: true,
+    check(context) {
+        if (context.binding.soapVersion !== '1.1') {
+            return NOT_APPLICABLE;
+        }
+        const findings = [];
+        let codes = 0;
+        for (const view of envelopes(context)) {
+            const fault = faultOf(view);
+            const code = fault === undefined ? undefined : unqualifiedChild(fault, 'faultcode');
+            if (code === undefined) {
+                continue;
+            }
+            codes += 1;
+            const value = (code.textContent ?? '').trim();
+            const colon = value.indexOf(':');
+            if (value.length === 0) {
+                findings.push(messageFinding(view, code, 'faultcode is empty'));
+            }
+            else if (colon > -1 && !inScopePrefixes(code).has(value.slice(0, colon))) {
+                findings.push(messageFinding(view, code, `faultcode "${value}" uses the prefix "${value.slice(0, colon)}", which is not declared in scope`));
+            }
+        }
+        return codes === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1103: a response carrying a `soap:Fault` uses the HTTP status `500 Internal Server
+ * Error`. A fault returned with `200 OK` is indistinguishable from a successful response to any
+ * intermediary that reads only the status line.
+ *
+ * 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 R1103: WsiMessageAssertion;

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

@@ -0,0 +1,28 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { faultOf, viewFinding } from './helpers.js';
+/**
+ * BP 1.1 R1103: a response carrying a `soap:Fault` uses the HTTP status `500 Internal Server
+ * Error`. A fault returned with `200 OK` is indistinguishable from a successful response to any
+ * intermediary that reads only the status line.
+ *
+ * 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 R1103 = {
+    id: 'R1103',
+    title: 'A response carrying a soap:Fault uses HTTP status 500',
+    level: 'REQUIRED',
+    section: '3.5 SOAP Faults',
+    unverifiedId: true,
+    check(context) {
+        const response = context.response;
+        if (response === undefined || faultOf(response) === undefined) {
+            return NOT_APPLICABLE;
+        }
+        const findings = [];
+        if (response.status !== 500) {
+            findings.push(viewFinding(response, `the response carries a soap:Fault but the HTTP status is ${String(response.status ?? 0)}, not 500`));
+        }
+        return findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1107: a fault's `detail` element carries no `soap:encodingStyle`. The detail of a
+ * literal fault is an instance of the schema the description declares, so naming an encoding for
+ * it would change how a receiver reads 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 R1107: WsiMessageAssertion;

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

@@ -0,0 +1,38 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { attributesOf, envelopes, faultOf, messageFinding, unqualifiedChild } from './helpers.js';
+import { descendants } from '../helpers.js';
+/**
+ * BP 1.1 R1107: a fault's `detail` element carries no `soap:encodingStyle`. The detail of a
+ * literal fault is an instance of the schema the description declares, so naming an encoding for
+ * it would change how a receiver reads 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 R1107 = {
+    id: 'R1107',
+    title: 'A fault detail carries no soap:encodingStyle',
+    level: 'REQUIRED',
+    section: '3.5 SOAP Faults',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        let details = 0;
+        for (const view of envelopes(context)) {
+            const fault = faultOf(view);
+            const detail = fault === undefined ? undefined : unqualifiedChild(fault, 'detail');
+            if (detail === undefined) {
+                continue;
+            }
+            details += 1;
+            for (const element of [detail, ...descendants(detail)]) {
+                for (const attribute of attributesOf(element)) {
+                    if (attribute.namespaceUri === view.soapNs && attribute.localName === 'encodingStyle') {
+                        findings.push(messageFinding(view, element, `"${element.nodeName}" inside soap:Fault/detail carries soap:encodingStyle="${attribute.value}"`));
+                    }
+                }
+            }
+        }
+        return details === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1109: the value of the `SOAPAction` HTTP header field is a quoted string. An empty
+ * action is the two characters `""`, not an empty header value — an unquoted action is a
+ * different string to a receiver that unquotes before comparing.
+ *
+ * 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 R1109: WsiMessageAssertion;

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

@@ -0,0 +1,32 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { headerValue, viewFinding } from './helpers.js';
+/**
+ * BP 1.1 R1109: the value of the `SOAPAction` HTTP header field is a quoted string. An empty
+ * action is the two characters `""`, not an empty header value — an unquoted action is a
+ * different string to a receiver that unquotes before comparing.
+ *
+ * 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 R1109 = {
+    id: 'R1109',
+    title: 'The SOAPAction request header is a quoted string',
+    level: 'REQUIRED',
+    section: '3.4 Use of SOAP in HTTP',
+    unverifiedId: true,
+    check(context) {
+        // SOAP 1.2 carries the action as a Content-Type parameter, not a header field.
+        if (context.binding.soapVersion !== '1.1') {
+            return NOT_APPLICABLE;
+        }
+        const value = headerValue(context.request, 'soapaction');
+        if (value === undefined) {
+            return NOT_APPLICABLE;
+        }
+        const findings = [];
+        if (!/^".*"$/s.test(value)) {
+            findings.push(viewFinding(context.request, `SOAPAction: ${value} is not a quoted string (an empty action is the two characters "")`));
+        }
+        return findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1124: an envelope that is not a fault is returned with the HTTP status 200 ("OK") or,
+ * for a one-way message, 202 ("Accepted"). This is one of section 3.4's HTTP-status rules, which
+ * the profile makes `REQUIRED`.
+ *
+ * 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 R1124: WsiMessageAssertion;

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

@@ -0,0 +1,31 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { faultOf, viewFinding } from './helpers.js';
+/** The status codes a successful SOAP/HTTP response is expected to carry. */
+const SUCCESS = [200, 202];
+/**
+ * BP 1.1 R1124: an envelope that is not a fault is returned with the HTTP status 200 ("OK") or,
+ * for a one-way message, 202 ("Accepted"). This is one of section 3.4's HTTP-status rules, which
+ * the profile makes `REQUIRED`.
+ *
+ * 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 R1124 = {
+    id: 'R1124',
+    title: 'A non-fault response carries HTTP status 200 or 202',
+    level: 'REQUIRED',
+    section: '3.4 Use of SOAP in HTTP',
+    unverifiedId: true,
+    check(context) {
+        const response = context.response;
+        if (response === undefined || faultOf(response) !== undefined) {
+            return NOT_APPLICABLE;
+        }
+        const findings = [];
+        const status = response.status ?? 0;
+        if (!SUCCESS.includes(status)) {
+            findings.push(viewFinding(response, `the response carries no soap:Fault but the HTTP status is ${String(status)}, not 200 or 202`));
+        }
+        return findings;
+    },
+};

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

@@ -0,0 +1,9 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1132: an HTTP request message uses the `POST` method. The envelope is the entity body,
+ * and only `POST` carries one an origin server is required to read.
+ *
+ * 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 R1132: WsiMessageAssertion;

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

@@ -0,0 +1,23 @@
+import { viewFinding } from './helpers.js';
+/**
+ * BP 1.1 R1132: an HTTP request message uses the `POST` method. The envelope is the entity body,
+ * and only `POST` carries one an origin server is required to read.
+ *
+ * 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 R1132 = {
+    id: 'R1132',
+    title: 'The HTTP request uses the POST method',
+    level: 'REQUIRED',
+    section: '3.4 Use of SOAP in HTTP',
+    unverifiedId: true,
+    check(context) {
+        const method = context.exchange.http.request.method.toUpperCase();
+        const findings = [];
+        if (method !== 'POST') {
+            findings.push(viewFinding(context.request, `the request was sent with HTTP ${method}; the profile requires POST`));
+        }
+        return findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1140: a message states the media type its SOAP version's HTTP binding defines —
+ * `text/xml` for SOAP 1.1. A multipart message (MTOM or SOAP with Attachments) is not judged
+ * here: its envelope's media type is the root part's, not the message's.
+ *
+ * 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 R1140: WsiMessageAssertion;

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

@@ -0,0 +1,42 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { headerValue, mediaTypeOf, viewFinding } from './helpers.js';
+/** The media type each SOAP version's HTTP binding uses. */
+const MEDIA_TYPE = {
+    '1.1': 'text/xml',
+    '1.2': 'application/soap+xml',
+};
+/**
+ * BP 1.1 R1140: a message states the media type its SOAP version's HTTP binding defines —
+ * `text/xml` for SOAP 1.1. A multipart message (MTOM or SOAP with Attachments) is not judged
+ * here: its envelope's media type is the root part's, not the message's.
+ *
+ * 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 R1140 = {
+    id: 'R1140',
+    title: 'Content-Type states the media type the SOAP version defines',
+    level: 'REQUIRED',
+    section: '3.4 Use of SOAP in HTTP',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        const expected = MEDIA_TYPE[context.binding.soapVersion];
+        let judged = 0;
+        for (const view of context.messages) {
+            const contentType = headerValue(view, 'content-type');
+            if (contentType === undefined) {
+                continue;
+            }
+            const mediaType = mediaTypeOf(contentType);
+            if (mediaType.startsWith('multipart/')) {
+                continue;
+            }
+            judged += 1;
+            if (mediaType !== expected) {
+                findings.push(viewFinding(view, `the ${view.direction} Content-Type media type is "${mediaType}"; SOAP ${context.binding.soapVersion} over HTTP uses "${expected}"`));
+            }
+        }
+        return judged === 0 ? NOT_APPLICABLE : findings;
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R1141: a message states a `charset` parameter on its `Content-Type`. Without it a
+ * `text/xml` entity defaults to US-ASCII under the HTTP rules while the XML declaration says
+ * UTF-8, and the two readings disagree the moment a non-ASCII character appears.
+ *
+ * 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 R1141: WsiMessageAssertion;

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

@@ -0,0 +1,32 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { charsetOf, headerValue, mediaTypeOf, viewFinding } from './helpers.js';
+/**
+ * BP 1.1 R1141: a message states a `charset` parameter on its `Content-Type`. Without it a
+ * `text/xml` entity defaults to US-ASCII under the HTTP rules while the XML declaration says
+ * UTF-8, and the two readings disagree the moment a non-ASCII character appears.
+ *
+ * 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 R1141 = {
+    id: 'R1141',
+    title: 'Content-Type states a charset parameter',
+    level: 'REQUIRED',
+    section: '3.4 Use of SOAP in HTTP',
+    unverifiedId: true,
+    check(context) {
+        const findings = [];
+        let judged = 0;
+        for (const view of context.messages) {
+            const contentType = headerValue(view, 'content-type');
+            if (contentType === undefined || mediaTypeOf(contentType).startsWith('multipart/')) {
+                continue;
+            }
+            judged += 1;
+            if (charsetOf(contentType) === undefined) {
+                findings.push(viewFinding(view, `the ${view.direction} Content-Type "${contentType}" states no charset parameter`));
+            }
+        }
+        return judged === 0 ? NOT_APPLICABLE : findings;
+    },
+};