@wirebench/engine 2.1.1

package/dist/validate/wsi/assertions/r2710.js

@@ -0,0 +1,37 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, soapBindings } from './helpers.js';
+/**
+ * BP 1.1 R2710: the operations of a `wsdl:binding` "MUST result in wire signatures that are
+ * different from one another".
+ *
+ * This is an **approximation**: the profile's subject is the *wire signature* (for document-literal,
+ * the qualified name of the body's first child; for rpc-literal, the wrapper element), which two
+ * differently-named operations can still share. What is checked here is the much cheaper and
+ * strictly narrower condition that no two operations of one binding share a `name` — the case
+ * that is both unambiguous and by far the most common. Operations whose names differ but whose
+ * wire signatures collide are not reported.
+ */
+export const R2710 = {
+    id: 'R2710',
+    title: 'Operation names are distinct within a binding (approximates wire-signature distinctness)',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let operations = 0;
+        for (const view of soapBindings(context)) {
+            const seen = new Set();
+            for (const operation of childElements(view.binding, NS.WSDL, 'operation')) {
+                operations += 1;
+                const name = optionalAttribute(operation, 'name') ?? '';
+                if (seen.has(name)) {
+                    findings.push(findingAt(view.location, operation, `wsdl:binding "${optionalAttribute(view.binding, 'name') ?? ''}" declares more than one operation named "${name}"`));
+                }
+                seen.add(name);
+            }
+        }
+        return operations === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2716.d.ts

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2716: a document-literal binding "MUST NOT have the namespace attribute specified on
+ * contained soapbind:body, soapbind:header, soapbind:headerfault and soapbind:fault elements" —
+ * the namespace comes from the global element declaration the part names.
+ */
+export declare const R2716: WsiAssertion;

package/dist/validate/wsi/assertions/r2716.js

@@ -0,0 +1,29 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, soapExtensions } from './helpers.js';
+/**
+ * BP 1.1 R2716: a document-literal binding "MUST NOT have the namespace attribute specified on
+ * contained soapbind:body, soapbind:header, soapbind:headerfault and soapbind:fault elements" —
+ * the namespace comes from the global element declaration the part names.
+ */
+export const R2716 = {
+    id: 'R2716',
+    title: 'document-literal soapbind elements declare no namespace attribute',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let elements = 0;
+        for (const view of soapExtensions(context)) {
+            if (view.style !== 'document') {
+                continue;
+            }
+            elements += 1;
+            const namespace = optionalAttribute(view.element, 'namespace');
+            if (namespace !== undefined) {
+                findings.push(findingAt(view.location, view.element, `document-literal soapbind:${view.kind} declares namespace="${namespace}"`));
+            }
+        }
+        return elements === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2717.d.ts

@@ -0,0 +1,9 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2717: an rpc-literal binding "MUST have the namespace attribute specified" on every
+ * contained `soapbind:body` — the operation wrapper element needs a namespace to live in.
+ *
+ * What that namespace may *be* is a separate requirement: {@link R2803} forbids a relative URI
+ * there. This assertion only checks that the attribute is present.
+ */
+export declare const R2717: WsiAssertion;

package/dist/validate/wsi/assertions/r2717.js

@@ -0,0 +1,31 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, soapExtensions } from './helpers.js';
+/**
+ * BP 1.1 R2717: an rpc-literal binding "MUST have the namespace attribute specified" on every
+ * contained `soapbind:body` — the operation wrapper element needs a namespace to live in.
+ *
+ * What that namespace may *be* is a separate requirement: {@link R2803} forbids a relative URI
+ * there. This assertion only checks that the attribute is present.
+ */
+export const R2717 = {
+    id: 'R2717',
+    title: 'rpc-literal soapbind:body declares a namespace attribute',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let bodies = 0;
+        for (const view of soapExtensions(context)) {
+            if (view.style !== 'rpc' || view.kind !== 'body') {
+                continue;
+            }
+            bodies += 1;
+            const namespace = optionalAttribute(view.element, 'namespace');
+            if (namespace === undefined) {
+                findings.push(findingAt(view.location, view.element, 'rpc-literal soapbind:body has no namespace attribute'));
+            }
+        }
+        return bodies === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2718.d.ts

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2718: a `wsdl:binding` "MUST have the same set of wsdl:operations as the wsdl:portType
+ * to which it refers" — a binding may neither bind an operation the interface does not declare nor
+ * leave one of its operations unbound.
+ */
+export declare const R2718: WsiAssertion;

package/dist/validate/wsi/assertions/r2718.js

@@ -0,0 +1,41 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, portTypeOf, soapBindings, wsdlDocuments } from './helpers.js';
+/**
+ * BP 1.1 R2718: a `wsdl:binding` "MUST have the same set of wsdl:operations as the wsdl:portType
+ * to which it refers" — a binding may neither bind an operation the interface does not declare nor
+ * leave one of its operations unbound.
+ */
+export const R2718 = {
+    id: 'R2718',
+    title: 'A binding binds exactly the operations of its portType',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const definitionsByLocation = new Map(wsdlDocuments(context).map((doc) => [doc.location, doc.definitions]));
+        const findings = [];
+        let compared = 0;
+        for (const view of soapBindings(context)) {
+            const definitions = definitionsByLocation.get(view.location);
+            const portType = definitions === undefined ? undefined : portTypeOf(context, view, definitions);
+            if (portType === undefined) {
+                continue;
+            }
+            compared += 1;
+            const bound = new Set(childElements(view.binding, NS.WSDL, 'operation').map((operation) => optionalAttribute(operation, 'name') ?? ''));
+            const declared = new Set(childElements(portType.element, NS.WSDL, 'operation').map((operation) => optionalAttribute(operation, 'name') ?? ''));
+            for (const name of bound) {
+                if (!declared.has(name)) {
+                    findings.push(findingAt(view.location, view.binding, `Binding operation "${name}" is not declared by the portType`));
+                }
+            }
+            for (const name of declared) {
+                if (!bound.has(name)) {
+                    findings.push(findingAt(view.location, view.binding, `portType operation "${name}" is not bound`));
+                }
+            }
+        }
+        return compared === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2720.d.ts

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2720: a `wsdl:binding` "MUST use the part attribute with a schema type of 'NMTOKEN' on
+ * all contained soapbind:header and soapbind:headerfault elements" — one header binds exactly one
+ * part, so a whitespace-separated list is out of profile.
+ */
+export declare const R2720: WsiAssertion;

package/dist/validate/wsi/assertions/r2720.js

@@ -0,0 +1,29 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, soapExtensions } from './helpers.js';
+/**
+ * BP 1.1 R2720: a `wsdl:binding` "MUST use the part attribute with a schema type of 'NMTOKEN' on
+ * all contained soapbind:header and soapbind:headerfault elements" — one header binds exactly one
+ * part, so a whitespace-separated list is out of profile.
+ */
+export const R2720 = {
+    id: 'R2720',
+    title: 'soapbind:header and headerfault name exactly one part',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let headers = 0;
+        for (const view of soapExtensions(context)) {
+            if (view.kind !== 'header' && view.kind !== 'headerfault') {
+                continue;
+            }
+            headers += 1;
+            const part = optionalAttribute(view.element, 'part');
+            if (part === undefined || /\s/.test(part.trim())) {
+                findings.push(findingAt(view.location, view.element, `soapbind:${view.kind} part="${part ?? ''}" must name exactly one wsdl:part`));
+            }
+        }
+        return headers === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2721.d.ts

@@ -0,0 +1,6 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2721: a `wsdl:binding` "MUST have the name attribute specified on all contained
+ * soapbind:fault elements" — without it the fault cannot be tied to the abstract `wsdl:fault`.
+ */
+export declare const R2721: WsiAssertion;

package/dist/validate/wsi/assertions/r2721.js

@@ -0,0 +1,27 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, soapExtensions } from './helpers.js';
+/**
+ * BP 1.1 R2721: a `wsdl:binding` "MUST have the name attribute specified on all contained
+ * soapbind:fault elements" — without it the fault cannot be tied to the abstract `wsdl:fault`.
+ */
+export const R2721 = {
+    id: 'R2721',
+    title: 'Every soapbind:fault carries a name attribute',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let faults = 0;
+        for (const view of soapExtensions(context)) {
+            if (view.kind !== 'fault') {
+                continue;
+            }
+            faults += 1;
+            if (optionalAttribute(view.element, 'name') === undefined) {
+                findings.push(findingAt(view.location, view.element, 'soapbind:fault has no name attribute'));
+            }
+        }
+        return faults === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2722.d.ts

@@ -0,0 +1,6 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2722: when a `soapbind:fault` carries a name attribute, its value "MUST match the value
+ * of the name attribute of the parent wsdl:fault" — the two describe the same fault.
+ */
+export declare const R2722: WsiAssertion;

package/dist/validate/wsi/assertions/r2722.js

@@ -0,0 +1,29 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, soapExtensions } from './helpers.js';
+/**
+ * BP 1.1 R2722: when a `soapbind:fault` carries a name attribute, its value "MUST match the value
+ * of the name attribute of the parent wsdl:fault" — the two describe the same fault.
+ */
+export const R2722 = {
+    id: 'R2722',
+    title: 'A soapbind:fault name matches its parent wsdl:fault',
+    level: 'REQUIRED',
+    section: '4.7 SOAP Binding',
+    check(context) {
+        const findings = [];
+        let faults = 0;
+        for (const view of soapExtensions(context)) {
+            const name = view.kind === 'fault' ? optionalAttribute(view.element, 'name') : undefined;
+            if (name === undefined || view.wsdlFault === undefined) {
+                continue;
+            }
+            faults += 1;
+            const parentName = optionalAttribute(view.wsdlFault, 'name');
+            if (parentName !== name) {
+                findings.push(findingAt(view.location, view.element, `soapbind:fault name="${name}" does not match the enclosing wsdl:fault name="${parentName ?? ''}"`));
+            }
+        }
+        return faults === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2801.d.ts

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2801: a description "MUST use XML Schema 1.0 Recommendation as the basis of user defined
+ * datatypes and structures" — a `wsdl:types` section holding a schema in one of the superseded
+ * XML Schema draft namespaces is out of profile.
+ */
+export declare const R2801: WsiAssertion;

package/dist/validate/wsi/assertions/r2801.js

@@ -0,0 +1,39 @@
+import { NS } from '../../../xml/namespaces.js';
+import { firstChildElement } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, wsdlDocuments } from './helpers.js';
+/**
+ * BP 1.1 R2801: a description "MUST use XML Schema 1.0 Recommendation as the basis of user defined
+ * datatypes and structures" — a `wsdl:types` section holding a schema in one of the superseded
+ * XML Schema draft namespaces is out of profile.
+ */
+export const R2801 = {
+    id: 'R2801',
+    title: 'Type definitions use the XML Schema 1.0 namespace',
+    level: 'REQUIRED',
+    section: '4.9 Namespaces',
+    check(context) {
+        const findings = [];
+        let children = 0;
+        for (const doc of wsdlDocuments(context)) {
+            const typesEl = firstChildElement(doc.definitions, NS.WSDL, 'types');
+            if (typesEl === undefined) {
+                continue;
+            }
+            for (let child = typesEl.firstChild; child !== null; child = child.nextSibling) {
+                if (child.nodeType !== 1) {
+                    continue;
+                }
+                const element = child;
+                if (element.localName !== 'schema') {
+                    continue;
+                }
+                children += 1;
+                if (element.namespaceURI !== NS.XSD) {
+                    findings.push(findingAt(doc.location, element, `wsdl:types holds a schema in namespace "${element.namespaceURI ?? ''}" rather than XML Schema 1.0`));
+                }
+            }
+        }
+        return children === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2803.d.ts

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2803: in a description, "the namespace attribute on the soapbind:body, soapbind:header,
+ * soapbind:headerfault and soapbind:fault elements MUST NOT be a relative URI" — a relative value
+ * has no stable base once the description moves.
+ */
+export declare const R2803: WsiAssertion;

package/dist/validate/wsi/assertions/r2803.js

@@ -0,0 +1,29 @@
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, isAbsoluteUri, soapExtensions } from './helpers.js';
+/**
+ * BP 1.1 R2803: in a description, "the namespace attribute on the soapbind:body, soapbind:header,
+ * soapbind:headerfault and soapbind:fault elements MUST NOT be a relative URI" — a relative value
+ * has no stable base once the description moves.
+ */
+export const R2803 = {
+    id: 'R2803',
+    title: 'soapbind namespace attributes are absolute URIs',
+    level: 'REQUIRED',
+    section: '4.9 Namespaces',
+    check(context) {
+        const findings = [];
+        let namespaces = 0;
+        for (const view of soapExtensions(context)) {
+            const namespace = optionalAttribute(view.element, 'namespace');
+            if (namespace === undefined) {
+                continue;
+            }
+            namespaces += 1;
+            if (!isAbsoluteUri(namespace)) {
+                findings.push(findingAt(view.location, view.element, `soapbind:${view.kind} namespace="${namespace}" is a relative URI`));
+            }
+        }
+        return namespaces === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/docs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Renders the assertion catalogue as Markdown.
+ *
+ * `docs/ws-i-assertions.md` is generated from this by `scripts/wsi-docs.ts` (`pnpm wsi:docs`), and
+ * `scripts/wsi-docs.test.ts` fails when the committed file drifts from the registry — the registry
+ * stays the single source of truth.
+ */
+import type { WsiAssertion, WsiAssertionLevel, WsiMessageAssertion } from './types.js';
+/** One assertion the catalogue names but does not implement yet. */
+export interface PlannedAssertion {
+    readonly id: string;
+    readonly level: WsiAssertionLevel;
+    readonly title: string;
+    readonly notes: string;
+}
+/**
+ * Assertions within the ranges the catalogue covers that are known to be missing, so the generated
+ * document states the gap instead of implying the profile is fully covered.
+ */
+export declare const WSI_PLANNED_ASSERTIONS: readonly PlannedAssertion[];
+/**
+ * Renders the catalogue: one table of implemented description assertions, one of implemented
+ * message assertions, and one of the known gaps.
+ *
+ * @param assertions the implemented description catalogue (defaults to the registry)
+ * @param planned the known gaps (defaults to {@link WSI_PLANNED_ASSERTIONS})
+ * @param messages the implemented message catalogue (defaults to the registry)
+ */
+export declare function renderWsiAssertionsMarkdown(assertions?: readonly WsiAssertion[], planned?: readonly PlannedAssertion[], messages?: readonly WsiMessageAssertion[]): string;

package/dist/validate/wsi/docs.js

@@ -0,0 +1,167 @@
+/**
+ * Renders the assertion catalogue as Markdown.
+ *
+ * `docs/ws-i-assertions.md` is generated from this by `scripts/wsi-docs.ts` (`pnpm wsi:docs`), and
+ * `scripts/wsi-docs.test.ts` fails when the committed file drifts from the registry — the registry
+ * stays the single source of truth.
+ */
+import { WSI_WSDL_ASSERTIONS } from './assertions/index.js';
+import { WSI_MESSAGE_ASSERTIONS } from './assertions/message/index.js';
+/**
+ * Assertions within the ranges the catalogue covers that are known to be missing, so the generated
+ * document states the gap instead of implying the profile is fully covered.
+ */
+export const WSI_PLANNED_ASSERTIONS = Object.freeze([
+    {
+        id: 'R2004',
+        level: 'REQUIRED',
+        title: 'An xs:import must not name a document whose root element is not xs:schema',
+        notes: 'Needs the resolver to keep documents it could not classify as a schema.',
+    },
+    {
+        id: 'R2114',
+        level: 'REQUIRED',
+        title: 'A description’s schema constructs stay within the profile’s XML Schema subset',
+        notes: 'Id and requirement text not verified against the published profile.',
+    },
+    {
+        id: 'R2202',
+        level: 'RECOMMENDED',
+        title: 'A description prefers the wrapped document-literal convention',
+        notes: 'Planned.',
+    },
+    {
+        id: 'R2207',
+        level: 'REQUIRED',
+        title: 'A wsdl:message part uses either the element or the type attribute, not both',
+        notes: 'Id and requirement text not verified against the published profile.',
+    },
+    {
+        id: 'R2208',
+        level: 'REQUIRED',
+        title: 'An rpc-literal operation’s parameterOrder names only parts of its messages',
+        notes: 'Id and requirement text not verified against the published profile.',
+    },
+    {
+        id: 'R1104',
+        level: 'REQUIRED',
+        title: 'A faultcode value is one of the four standard codes, or a QName outside the SOAP namespace',
+        notes: 'Message-level; id and requirement text not verified against the published profile.',
+    },
+    {
+        id: 'R2301',
+        level: 'REQUIRED',
+        title: 'The order of body children matches the order of the wsdl:parts',
+        notes: 'Message-level; not yet in the message assertion catalogue (see the Messages table).',
+    },
+    {
+        id: 'R2302',
+        level: 'REQUIRED',
+        title: 'An rpc-literal envelope names its part accessors after the wsdl:parts',
+        notes: 'Message-level; not yet in the message assertion catalogue (see the Messages table).',
+    },
+    {
+        id: 'R2305',
+        level: 'REQUIRED',
+        title: 'A document-literal envelope carries the element declared by the bound part',
+        notes: 'Message-level; not yet in the message assertion catalogue (see the Messages table).',
+    },
+    {
+        id: 'R2707',
+        level: 'REQUIRED',
+        title: 'Every soapbind element states the use attribute explicitly',
+        notes: 'R2706 only checks the ones that state it; stating it is a separate requirement.',
+    },
+    {
+        id: 'R2724',
+        level: 'REQUIRED',
+        title: 'An instance places the parts a soapbind:header names in the SOAP header',
+        notes: 'Message-level; id and requirement text not verified against the published profile.',
+    },
+    {
+        id: 'R2725',
+        level: 'REQUIRED',
+        title: 'An instance places the parts a soapbind:headerfault names in a header fault',
+        notes: 'Message-level; id and requirement text not verified against the published profile.',
+    },
+    {
+        id: 'R2726',
+        level: 'REQUIRED',
+        title: 'An instance must not carry a soapbind:header part the binding does not declare',
+        notes: 'Message-level; id and requirement text not verified against the published profile.',
+    },
+    {
+        id: 'R2802',
+        level: 'REQUIRED',
+        title: 'The description declares the WSDL 1.1 namespaces the profile mandates',
+        notes: 'Planned.',
+    },
+]);
+/** Escapes the pipe characters that would break a Markdown table cell. */
+function cell(value) {
+    return value.replace(/\|/g, '\\|');
+}
+/** Renders one assertion as a row of the implemented table. */
+function implementedRow(assertion) {
+    return `| ${assertion.id} | ${assertion.level} | ${cell(assertion.title)} | ${assertion.unverifiedId === true ? 'Implemented (id unverified)' : 'Implemented'} | ${cell(assertion.section)} |`;
+}
+/**
+ * Renders the catalogue: one table of implemented description assertions, one of implemented
+ * message assertions, and one of the known gaps.
+ *
+ * @param assertions the implemented description catalogue (defaults to the registry)
+ * @param planned the known gaps (defaults to {@link WSI_PLANNED_ASSERTIONS})
+ * @param messages the implemented message catalogue (defaults to the registry)
+ */
+export function renderWsiAssertionsMarkdown(assertions = WSI_WSDL_ASSERTIONS, planned = WSI_PLANNED_ASSERTIONS, messages = WSI_MESSAGE_ASSERTIONS) {
+    const lines = [
+        '# WS-I Basic Profile 1.1 assertions',
+        '',
+        '<!--',
+        '  Generated by `pnpm wsi:docs` from packages/engine/src/validate/wsi/assertions/index.ts.',
+        '  Do not edit by hand: `pnpm wsi:docs --check` (and scripts/wsi-docs.test.ts) fail on drift.',
+        '-->',
+        '',
+        `Wirebench implements ${assertions.length} description-level and ${messages.length} message-level`,
+        'assertions of the WS-I Basic Profile 1.1.',
+        'Each is evaluated against a description and reports `passed`, `failed` (a `REQUIRED`',
+        'assertion), `warning` (a `RECOMMENDED` one) or `notApplicable` when the construct it examines',
+        'does not occur. Profile requirement text is paraphrased; see the profile itself for the',
+        'normative wording.',
+        '',
+        'A row marked *id unverified* implements a requirement Wirebench is confident about but whose',
+        'requirement **number** could not be confirmed against the published profile; treat the id as',
+        'provisional. The Planned table lists every id in the ranges this catalogue covers',
+        '(`R2001`–`R2005`, `R2101`–`R2114`, `R2201`–`R2211`, `R2301`–`R2305`, `R2401`, `R2701`–`R2726`,',
+        '`R2801`–`R2803`) that is known to be missing, so the coverage above is not overstated.',
+        '',
+        '## Implemented — descriptions',
+        '',
+        'Evaluated against a WSDL description by `runWsdlAssertions`.',
+        '',
+        '| Id | Level | Title | Status | Section |',
+        '| --- | --- | --- | --- | --- |',
+        ...assertions.map(implementedRow),
+        '',
+        '## Implemented — messages',
+        '',
+        'Evaluated against one SOAP exchange — request and response — by `runMessageAssertions`.',
+        'Every `R1xxx` row below is marked *id unverified*: the requirements are real and are',
+        'implemented as described, but ws-i.org could not be reached from the environment this',
+        "catalogue was written in, so the requirement **numbers** are Wirebench's best attribution",
+        'rather than a transcription. Quote the titles, not the ids, until they have been checked',
+        'against the published profile.',
+        '',
+        '| Id | Level | Title | Status | Section |',
+        '| --- | --- | --- | --- | --- |',
+        ...messages.map(implementedRow),
+        '',
+        '## Planned',
+        '',
+        '| Id | Level | Title | Status | Notes |',
+        '| --- | --- | --- | --- | --- |',
+        ...planned.map((entry) => `| ${entry.id} | ${entry.level} | ${cell(entry.title)} | Planned | ${cell(entry.notes)} |`),
+        '',
+    ];
+    return `${lines.join('\n')}`;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * WS-I Basic Profile 1.1 conformance analysis: of a WSDL description (`run-wsdl.ts`) and of one
+ * SOAP exchange (`run-message.ts`), plus the shared HTML report renderer.
+ */
+export type { WsiAssertion, WsiAssertionLevel, WsiAssertionReport, WsiAssertionResult, WsiCheckOutcome, WsiFinding, WsiLocation, WsiNotApplicable, WsiReport, WsiSummary, WsiWsdlContext, WsiMessageAssertion, WsiMessageBinding, WsiMessageContext, WsiMessageDirection, WsiMessageView, } from './types.js';
+export { NOT_APPLICABLE, isNotApplicable } from './types.js';
+export { WSI_WSDL_ASSERTIONS } from './assertions/index.js';
+export { runWsdlAssertions, wsiWsdlContext, wsiProblems } from './run-wsdl.js';
+export type { RunWsdlAssertionsOptions, WsiWsdlContextInput } from './run-wsdl.js';
+export { WSI_MESSAGE_ASSERTIONS } from './assertions/message/index.js';
+export { messageBindingFor, runMessageAssertions, wsiMessageContext } from './run-message.js';
+export type { RunMessageAssertionsOptions } from './run-message.js';
+export { escapeHtml, renderWsiReportHtml } from './report-html.js';
+export type { RenderWsiReportHtmlOptions } from './report-html.js';
+export { renderWsiAssertionsMarkdown, WSI_PLANNED_ASSERTIONS } from './docs.js';
+export type { PlannedAssertion } from './docs.js';

package/dist/validate/wsi/index.js

@@ -0,0 +1,11 @@
+/**
+ * WS-I Basic Profile 1.1 conformance analysis: of a WSDL description (`run-wsdl.ts`) and of one
+ * SOAP exchange (`run-message.ts`), plus the shared HTML report renderer.
+ */
+export { NOT_APPLICABLE, isNotApplicable } from './types.js';
+export { WSI_WSDL_ASSERTIONS } from './assertions/index.js';
+export { runWsdlAssertions, wsiWsdlContext, wsiProblems } from './run-wsdl.js';
+export { WSI_MESSAGE_ASSERTIONS } from './assertions/message/index.js';
+export { messageBindingFor, runMessageAssertions, wsiMessageContext } from './run-message.js';
+export { escapeHtml, renderWsiReportHtml } from './report-html.js';
+export { renderWsiAssertionsMarkdown, WSI_PLANNED_ASSERTIONS } from './docs.js';

package/dist/validate/wsi/report-html.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Renders a {@link WsiReport} as a self-contained HTML document.
+ *
+ * "Self-contained" is the whole point: the file a user exports has to open from a mail
+ * attachment, a ticket, or a shared drive years from now, so it carries its own inline CSS and
+ * nothing else — no script, no font, no stylesheet, no image, nothing that resolves over the
+ * network. Every value that reaches the markup goes through {@link escapeHtml} first: a finding
+ * quotes the offending element's name straight out of somebody else's message.
+ */
+import type { WsiReport } from './types.js';
+/** Escapes the five characters that could otherwise close a tag or an attribute. */
+export declare function escapeHtml(value: string): string;
+/** Options for {@link renderWsiReportHtml}. */
+export interface RenderWsiReportHtmlOptions {
+    /** The document title and page heading, e.g. the interface or request name. */
+    readonly title: string;
+    /**
+     * The timestamp printed in the header, as an ISO 8601 string. Injected rather than read from
+     * the clock so the output is a deterministic function of its input (and so the snapshot test
+     * has something stable to compare).
+     */
+    readonly generatedAt: string;
+    /**
+     * Whether the table includes the `passed`/`notApplicable` rows the report carries. It only
+     * ever *removes* rows: a report produced without `verbose` has no passing rows to show.
+     */
+    readonly verbose?: boolean;
+}
+/**
+ * Renders one WS-I report as a standalone HTML document.
+ *
+ * @param report the report to render, from `runWsdlAssertions` or `runMessageAssertions`
+ * @param options the heading, the (injected) timestamp, and whether to keep non-failing rows
+ * @returns a complete HTML document with no external references of any kind
+ */
+export declare function renderWsiReportHtml(report: WsiReport, options: RenderWsiReportHtmlOptions): string;