@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

package/dist/compiler/validateSemanticGraph.js

@@ -0,0 +1,376 @@
+/** One explicit graph reader boundary; typed fields are checked before identity/reference integrity. */
+import { DEFAULT_GRAPH_NODES, GRAPH_MODEL, globalId, scopedId, isBuiltinType, wsdlReferenceRoles } from "./canonicalGraph.js";
+import { CatalogError, positiveLimit, canonicalJson } from "./catalogErrors.js";
+import { resolveLexicalQName, syntaxAttribute, syntaxElements, XSD_NAMESPACE } from "../loader/orderedSyntax.js";
+const invalid = (field, reason) => { throw new CatalogError("invalid-schema", `Malformed catalog: ${reason}`, field); };
+const str = (v, p) => { if (typeof v !== "string")
+    invalid(p, "expected string"); };
+const bool = (v, p) => { if (typeof v !== "boolean")
+    invalid(p, "expected boolean"); };
+const integer = (min) => (v, p) => { if (!Number.isSafeInteger(v) || v < min)
+    invalid(p, "expected safe integer"); };
+const enumeration = (...values) => (v, p) => { if (!values.includes(v))
+    invalid(p, "unknown discriminant or value"); };
+const pattern = (regexp) => (v, p) => { str(v, p); if (!regexp.test(v))
+    invalid(p, "invalid string shape"); };
+const array = (check) => (v, p) => { if (!Array.isArray(v))
+    invalid(p, "expected array"); v.forEach((c, i) => check(c, `${p}/${i}`)); };
+const field = (check, optional = false) => ({ check, optional });
+const object = (fields) => (v, p) => {
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        invalid(p, "expected object");
+    const o = v;
+    for (const k of Object.keys(o))
+        if (!Object.hasOwn(fields, k))
+            invalid(`${p}/${k}`, "unknown mandatory field");
+    for (const [k, f] of Object.entries(fields)) {
+        if (!Object.hasOwn(o, k)) {
+            if (!f.optional)
+                invalid(`${p}/${k}`, "missing required field");
+        }
+        else
+            f.check(o[k], `${p}/${k}`);
+    }
+};
+const record = (check) => (v, p) => {
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        invalid(p, "expected record");
+    for (const [k, c] of Object.entries(v))
+        check(c, `${p}/${k}`);
+};
+const discriminator = (key, variants) => (v, p) => {
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        invalid(p, "expected discriminated object");
+    const tag = v[key];
+    if (typeof tag !== "string" || !Object.hasOwn(variants, tag))
+        invalid(`${p}/${key}`, "unknown discriminant");
+    variants[tag](v, p);
+};
+const roles = ["element", "attribute", "type", "group", "attributeGroup", "message", "portType", "binding", "service"];
+const role = enumeration(...roles);
+const digest = pattern(/^[a-f0-9]{64}$/);
+const sourceUri = pattern(/^urn:source:sha256:[a-f0-9]{64}$/);
+const baseUri = pattern(/^urn:base:sha256:[a-f0-9]{64}$/);
+const interpretation = (v, p) => {
+    str(v, p);
+    if (/^urn:source:sha256:[a-f0-9]{64}$/.test(v))
+        return;
+    let tuple;
+    try {
+        tuple = JSON.parse(v);
+    }
+    catch {
+        invalid(p, "invalid interpretation key");
+    }
+    if (!Array.isArray(tuple) || tuple.length !== 7)
+        invalid(p, "invalid interpretation tuple");
+    const t = tuple;
+    [digest, sourceUri, baseUri, str, enumeration("root", "inline", "include", "import"), str, pattern(/^(?:\/\d+)+$/)].forEach((check, i) => check(t[i], `${p}/${i}`));
+    if (t[1] !== `urn:source:sha256:${t[0]}`)
+        invalid(p, "inconsistent interpretation resource");
+};
+const position = object({ offset: field(integer(0)), line: field(integer(1)), column: field(integer(1)) });
+const source = (v, p) => {
+    object({ uri: field(sourceUri), digest: field(digest), path: field(pattern(/^(?:\/\d+)+$/)), start: field(position), end: field(position) })(v, p);
+    const s = v;
+    if (s.uri !== `urn:source:sha256:${s.digest}` || s.start.offset > s.end.offset)
+        invalid(p, "inconsistent source digest/span");
+};
+const name = (v, p) => {
+    object({ namespace: field(str), local: field(str) })(v, p);
+    const n = v;
+    try {
+        if (n.local.includes(":") || resolveLexicalQName(n.local, { namespaces: Object.create(null) }).local !== n.local)
+            invalid(p, "invalid canonical NCName");
+    }
+    catch (e) {
+        if (e instanceof CatalogError)
+            throw e;
+        invalid(p, "invalid canonical NCName");
+    }
+};
+const attribute = object({ name: field(name), lexicalName: field(str), value: field(str) });
+const context = object({ namespaces: field(record(str)), baseUri: field(baseUri), source: field(source), effectiveNamespace: field(str), chameleon: field(bool), schemaAttributes: field(array(attribute)) });
+const lexical = object({ value: field(str), context: field(context) });
+const syntax = (v, p) => discriminator("kind", {
+    text: object({ kind: field(enumeration("text")), value: field(str), source: field(source) }),
+    element: object({ kind: field(enumeration("element")), name: field(name), lexicalName: field(str), attributes: field(array(attribute)), namespaces: field(record(str)), baseUri: field(baseUri), source: field(source), children: field(array(syntax)) }),
+})(v, p);
+const elementSyntax = (v, p) => { syntax(v, p); if (v.kind !== "element")
+    invalid(p, "expected element syntax"); };
+const value = object({ kind: field(enumeration("default", "fixed")), lexical: field(lexical) });
+const facet = object({ name: field(enumeration("enumeration", "pattern", "whiteSpace", "length", "minLength", "maxLength", "minInclusive", "minExclusive", "maxInclusive", "maxExclusive", "totalDigits", "fractionDigits")), lexical: field(lexical), fixed: field(bool), syntax: field(elementSyntax) });
+const wildcard = object({ namespace: field(lexical), processContents: field(enumeration("strict", "lax", "skip")) });
+const identity = discriminator("kind", {
+    global: object({ kind: field(enumeration("global")), role: field(role), name: field(name) }),
+    scoped: object({ kind: field(enumeration("scoped")), owner: field(str), path: field(pattern(/^(?:\/\d+)+$|^\/$/)), role: field(str) }),
+});
+const occurs = (v, p) => {
+    object({ min: field(pattern(/^(?:0|[1-9]\d*)$/)), max: field((v, p) => { if (v !== "unbounded")
+            pattern(/^(?:0|[1-9]\d*)$/)(v, p); }) })(v, p);
+    const { min, max } = v;
+    if (max !== "unbounded" && (min.length > max.length || (min.length === max.length && min > max)))
+        invalid(p, "occurrence minimum exceeds maximum");
+};
+const base = { id: field(str), identity: field(identity), context: field(context), declaredAttributes: field(array(attribute)), annotations: field(array(elementSyntax)), retained: field(array(elementSyntax)), syntaxDetails: field(array(elementSyntax)) };
+const attrs = field(array(str));
+export function validateSemanticGraph(input, options = {}) {
+    const maxNodes = positiveLimit(options.maxNodes, DEFAULT_GRAPH_NODES, "maxNodes");
+    const refs = [];
+    const reference = (...expected) => (v, p) => {
+        discriminator("kind", {
+            symbol: object({ kind: field(enumeration("symbol")), role: field(enumeration(...expected)), name: field(name), lexical: field(lexical), target: field(str, true) }),
+            builtin: object({ kind: field(enumeration("builtin")), name: field(name), lexical: field(lexical, true) }),
+            local: object({ kind: field(enumeration("local")), target: field(str) }),
+        })(v, p);
+        refs.push({ reference: v, expected, field: p });
+    };
+    const term = discriminator("kind", {
+        sequence: object({ kind: field(enumeration("sequence")), children: attrs }),
+        choice: object({ kind: field(enumeration("choice")), children: attrs }),
+        all: object({ kind: field(enumeration("all")), children: attrs }),
+        element: object({ kind: field(enumeration("element")), declaration: field(reference("element")) }),
+        group: object({ kind: field(enumeration("group")), reference: field(reference("group")) }),
+        any: object({ kind: field(enumeration("any")), wildcard: field(wildcard) }),
+    });
+    const node = discriminator("kind", {
+        element: object({ ...base, kind: field(enumeration("element")), name: field(name), type: field(reference("type")), nillable: field(bool), abstract: field(bool), value: field(value, true), substitutionGroup: field(reference("element"), true) }),
+        attribute: object({ ...base, kind: field(enumeration("attribute")), name: field(name), type: field(reference("type")), value: field(value, true) }),
+        particle: object({ ...base, kind: field(enumeration("particle")), occurs: field(occurs), term: field(term) }),
+        attributeUse: object({ ...base, kind: field(enumeration("attributeUse")), declaration: field(reference("attribute")), use: field(enumeration("optional", "required", "prohibited")), value: field(value, true) }),
+        attributeGroupUse: object({ ...base, kind: field(enumeration("attributeGroupUse")), reference: field(reference("attributeGroup")) }),
+        attributeWildcard: object({ ...base, kind: field(enumeration("attributeWildcard")), wildcard: field(wildcard) }),
+        simpleType: object({ ...base, kind: field(enumeration("simpleType")), variety: field(discriminator("kind", {
+                restriction: object({ kind: field(enumeration("restriction")), base: field(reference("type")), facets: field(array(facet)) }),
+                list: object({ kind: field(enumeration("list")), item: field(reference("type")) }),
+                union: object({ kind: field(enumeration("union")), members: field(array(reference("type"))) }),
+            })) }),
+        complexType: object({ ...base, kind: field(enumeration("complexType")), mixed: field(bool), abstract: field(bool), content: field(str, true), attributes: attrs,
+            derivation: field(object({ kind: field(enumeration("extension", "restriction")), contentKind: field(enumeration("simple", "complex")), base: field(reference("type")), inlineType: field(reference("type"), true), facets: field(array(facet)) }), true) }),
+        group: object({ ...base, kind: field(enumeration("group")), content: field(str) }),
+        attributeGroup: object({ ...base, kind: field(enumeration("attributeGroup")), attributes: attrs }),
+        wsdl: object({ ...base, kind: field(enumeration("wsdl")), role: field(enumeration("message", "portType", "binding", "service")), name: field(name), syntax: field(elementSyntax),
+            references: field(array(object({ path: field(str), attribute: field(str), reference: field(reference(...roles)) }))) }),
+    });
+    object({ model: field(enumeration(GRAPH_MODEL)), nodes: field((v, p) => {
+            if (!Array.isArray(v))
+                invalid(p, "expected node array");
+            if (v.length > maxNodes)
+                throw new CatalogError("resource-limit", `Catalog graph exceeds ${maxNodes} nodes`, p);
+            array(node)(v, p);
+        }), globals: field(array(str)), origins: field(record(array(object({ interpretation: field(interpretation), context: field(context) })))),
+        schemaAnnotations: field(array(elementSyntax)), schemaRetained: field(array(object({ context: field(context), syntax: field(elementSyntax) }))),
+        loading: field(object({ limits: field(object({ resources: field(integer(1)), resourceBytes: field(integer(1)), totalBytes: field(integer(1)), resolutionDepth: field(integer(1)), redirects: field(integer(0)), resourceMs: field(integer(1)), totalIoMs: field(integer(1)), syntaxDepth: field(integer(1)) })),
+            edges: field(array(object({ kind: field(enumeration("include", "import", "wsdl-import")), from: field(interpretation), to: field(interpretation, true), referenceUri: field(baseUri, true), source: field(source), cycle: field(bool) }))) })), })(input, "graph");
+    const graph = input, nodes = new Map();
+    const nodeRole = (n) => !n ? undefined : n.kind === "simpleType" || n.kind === "complexType" ? "type" : n.kind === "wsdl" ? n.role : roles.includes(n.kind) ? n.kind : undefined;
+    for (const n of graph.nodes) {
+        if (nodes.has(n.id))
+            invalid(`graph/nodes/${n.id}`, "duplicate node identity");
+        const expectedId = n.identity.kind === "global" ? globalId(n.identity.role, n.identity.name) : scopedId(n.identity.owner, n.identity.path, n.identity.role);
+        if (n.id !== expectedId)
+            invalid(`graph/nodes/${n.id}`, "identity does not match ID");
+        if (n.identity.kind === "global" && (nodeRole(n) !== n.identity.role || ("name" in n && (n.name.namespace !== n.identity.name.namespace || n.name.local !== n.identity.name.local))))
+            invalid(`graph/nodes/${n.id}`, "global symbol role/name mismatch");
+        if (n.identity.kind === "scoped") {
+            const expectedRole = n.kind === "simpleType" || n.kind === "complexType" ? "type" : ["attributeUse", "attributeGroupUse", "attributeWildcard"].includes(n.kind) ? "attributeUse" : n.kind;
+            if (n.identity.role !== expectedRole)
+                invalid(n.id, "scoped role disagrees with node kind");
+        }
+        nodes.set(n.id, n);
+    }
+    const expectedGlobals = graph.nodes.filter(n => n.identity.kind === "global").map(n => n.id).sort();
+    if (JSON.stringify([...graph.globals].sort()) !== JSON.stringify(expectedGlobals))
+        invalid("graph/globals", "global index does not match declarations");
+    if (Object.keys(graph.origins).length !== nodes.size)
+        invalid("graph/origins", "provenance index does not match nodes");
+    for (const n of graph.nodes) {
+        if (!Object.hasOwn(graph.origins, n.id) || !graph.origins[n.id].length)
+            invalid("graph/origins", "missing node provenance");
+        if (n.identity.kind === "scoped" && !nodeRole(nodes.get(n.identity.owner)))
+            invalid(`graph/nodes/${n.id}/identity/owner`, "missing or invalid containing declaration");
+        for (const origin of graph.origins[n.id]) {
+            if (origin.interpretation.startsWith("urn:")) {
+                if (origin.interpretation !== origin.context.source.uri)
+                    invalid(n.id, "inconsistent document provenance");
+            }
+            else {
+                const t = JSON.parse(origin.interpretation);
+                if (t[0] !== origin.context.source.digest || t[3] !== origin.context.effectiveNamespace || !(origin.context.source.path === t[6] || origin.context.source.path.startsWith(t[6] + "/")))
+                    invalid(n.id, "inconsistent schema provenance");
+            }
+        }
+    }
+    const get = (id, allowed, field) => {
+        const n = nodes.get(id);
+        if (!n || !allowed.includes(n.kind))
+            invalid(field, "missing or wrong-role reference target");
+        return n;
+    };
+    const structural = new Map();
+    for (const n of graph.nodes) {
+        const children = [];
+        if (n.kind === "particle" && ["sequence", "choice", "all"].includes(n.term.kind)) {
+            const term = n.term;
+            for (const id of term.children)
+                get(id, ["particle"], `graph/nodes/${n.id}/term/children`);
+            children.push(...term.children);
+            if (term.children.some(id => { const child = nodes.get(id); return child.kind === "particle" && child.term.kind === "all"; }))
+                invalid(n.id, "all cannot be nested inside a compositor");
+            if (term.kind === "all") {
+                if (n.occurs.max !== "1" || !["0", "1"].includes(n.occurs.min))
+                    invalid(n.id, "illegal all occurrence");
+                for (const id of term.children) {
+                    const child = nodes.get(id);
+                    if (child.kind !== "particle" || child.term.kind !== "element" || !["0", "1"].includes(child.occurs.min) || !["0", "1"].includes(child.occurs.max))
+                        invalid(n.id, "illegal all child");
+                }
+            }
+        }
+        if (n.kind === "complexType" || n.kind === "group") {
+            if (n.content) {
+                const content = get(n.content, ["particle"], `${n.id}/content`);
+                if (!(n.kind === "group" ? ["sequence", "choice", "all"] : ["sequence", "choice", "all", "group"]).includes(content.term.kind))
+                    invalid(n.id, "invalid declaration content particle");
+                if (n.kind === "group" && (content.occurs.min !== "1" || content.occurs.max !== "1"))
+                    invalid(n.id, "group definition has occurrence bounds");
+                if (n.kind === "complexType" && n.derivation?.contentKind === "simple")
+                    invalid(n.id, "simple content cannot contain a particle");
+                children.push(n.content);
+            }
+        }
+        if (n.kind === "simpleType" && n.variety.kind === "union" && !n.variety.members.length)
+            invalid(n.id, "empty union");
+        if (n.kind === "complexType" || n.kind === "attributeGroup")
+            for (const id of n.attributes) {
+                get(id, ["attributeUse", "attributeGroupUse", "attributeWildcard"], `${n.id}/attributes`);
+                children.push(id);
+            }
+        if (new Set(children).size !== children.length)
+            invalid(n.id, "duplicate structural use site");
+        const owner = n.kind === "particle" && n.identity.kind === "scoped" ? n.identity.owner : n.id;
+        for (const id of children) {
+            const child = nodes.get(id);
+            if (child.identity.kind !== "scoped" || child.identity.owner !== owner)
+                invalid(n.id, "structural child belongs to a different declaration");
+        }
+        structural.set(n.id, children);
+    }
+    for (const { reference: r, expected, field: p } of refs) {
+        if (r.kind === "builtin") {
+            if (!expected.includes("type") || r.name.namespace !== XSD_NAMESPACE || !isBuiltinType(r.name.local))
+                invalid(p, "invalid builtin type reference");
+            if (r.lexical) {
+                try {
+                    const resolved = resolveLexicalQName(r.lexical.value, { namespaces: Object.assign(Object.create(null), r.lexical.context.namespaces), source: r.lexical.context.source });
+                    if (resolved.namespace !== r.name.namespace || resolved.local !== r.name.local)
+                        invalid(p, "builtin QName context disagrees with reference");
+                }
+                catch (e) {
+                    if (e instanceof CatalogError)
+                        throw e;
+                    invalid(p, "invalid builtin QName context");
+                }
+            }
+        }
+        else if (r.kind === "symbol") {
+            const expectedId = globalId(r.role, r.name), target = nodes.get(expectedId);
+            if ((r.target !== undefined && r.target !== expectedId) || (r.target !== undefined && !target) || (target && r.target === undefined))
+                invalid(p, "corrupt symbol link");
+            try {
+                const lexicalName = resolveLexicalQName(r.lexical.value, { namespaces: Object.assign(Object.create(null), r.lexical.context.namespaces), source: r.lexical.context.source });
+                const namespace = !lexicalName.namespace && r.lexical.context.chameleon ? r.lexical.context.effectiveNamespace : lexicalName.namespace;
+                if (namespace !== r.name.namespace || lexicalName.local !== r.name.local)
+                    invalid(p, "QName context disagrees with reference identity");
+            }
+            catch (e) {
+                if (e instanceof CatalogError)
+                    throw e;
+                invalid(p, "invalid lexical QName context");
+            }
+        }
+        else {
+            const target = nodes.get(r.target);
+            if (!target || !expected.includes(nodeRole(target)))
+                invalid(p, "corrupt local declaration reference");
+            const from = graph.nodes[Number(p.split("/")[2])];
+            const owner = ["particle", "attributeUse"].includes(from.kind) && from.identity.kind === "scoped" ? from.identity.owner : from.id;
+            if (target.identity.kind !== "scoped" || target.identity.owner !== owner)
+                invalid(p, "local reference belongs to a different declaration");
+            structural.get(from.id).push(r.target);
+        }
+    }
+    for (const n of graph.nodes)
+        if (n.kind === "wsdl") {
+            const expected = [];
+            const visit = (s) => {
+                for (const [attribute, role] of Object.entries(wsdlReferenceRoles(s))) {
+                    const value = syntaxAttribute(s, attribute);
+                    if (value !== undefined)
+                        expected.push({ path: s.source.path.slice(n.syntax.source.path.length) || "/", attribute, role, value, syntax: s });
+                }
+                for (const child of syntaxElements(s))
+                    visit(child);
+            };
+            visit(n.syntax);
+            if (expected.length !== n.references.length)
+                invalid(n.id, "WSDL reference index incomplete");
+            expected.forEach((e, i) => {
+                const r = n.references[i];
+                if (r.path !== e.path || r.attribute !== e.attribute || r.reference.kind === "local" || (r.reference.kind === "symbol" && r.reference.role !== e.role) || r.reference.lexical?.value !== e.value)
+                    invalid(n.id, "WSDL reference role/context mismatch");
+                const c = r.reference.kind !== "local" ? r.reference.lexical?.context : undefined;
+                if (!c || canonicalJson(c.namespaces) !== canonicalJson(e.syntax.namespaces) || canonicalJson(c.source) !== canonicalJson(e.syntax.source) || c.baseUri !== e.syntax.baseUri || c.effectiveNamespace !== n.context.effectiveNamespace || c.chameleon !== n.context.chameleon || canonicalJson(c.schemaAttributes) !== canonicalJson(n.context.schemaAttributes))
+                    invalid(n.id, "WSDL reference disagrees with declaring syntax context");
+            });
+        }
+    const parents = new Map();
+    for (const [parent, children] of structural)
+        for (const child of children) {
+            if (parents.has(child))
+                invalid(child, "structural use site has multiple parents");
+            parents.set(child, parent);
+        }
+    for (const n of graph.nodes)
+        if (n.identity.kind === "scoped") {
+            if (!parents.has(n.id))
+                invalid(n.id, "orphan scoped use site or declaration");
+            const owner = nodes.get(n.identity.owner);
+            if (n.context.source.path !== owner.context.source.path + (n.identity.path === "/" ? "" : n.identity.path))
+                invalid(n.id, "scoped path disagrees with containing declaration");
+        }
+    // Ownership and structural containment must be acyclic. Semantic recursion through references is legal.
+    const complete = new Set(), active = new Set();
+    for (const id of nodes.keys()) {
+        const stack = [{ id, exit: false }];
+        while (stack.length) {
+            const item = stack.pop();
+            if (item.exit) {
+                active.delete(item.id);
+                complete.add(item.id);
+                continue;
+            }
+            if (complete.has(item.id))
+                continue;
+            if (active.has(item.id))
+                invalid(item.id, "cyclic structural containment");
+            active.add(item.id);
+            stack.push({ id: item.id, exit: true });
+            for (const child of [...(structural.get(item.id) ?? [])].reverse())
+                stack.push({ id: child, exit: false });
+        }
+    }
+    const ownersDone = new Set();
+    for (const n of graph.nodes) {
+        let current = n;
+        const path = new Set();
+        while (current.identity.kind === "scoped" && !ownersDone.has(current.id)) {
+            if (path.has(current.id))
+                invalid(n.id, "cyclic declaration ownership");
+            path.add(current.id);
+            current = nodes.get(current.identity.owner);
+        }
+        for (const id of path)
+            ownersDone.add(id);
+    }
+}

package/dist/compiler/wildcardAlgebra.d.ts

@@ -0,0 +1,26 @@
+/** XSD 1.0 namespace algebra. These local relations do not certify a schema. */
+import type { Wildcard } from './canonicalGraph.js';
+export type NamespaceConstraint = Readonly<{
+    kind: 'set' | 'not';
+    namespaces: readonly string[];
+}>;
+export type WildcardProcess = Wildcard['processContents'];
+export type WildcardCharge = (amount?: number) => void;
+/** Canonical mathematical namespace properties; no XML lexical form is invented. */
+export declare function canonicalNamespaceConstraint(value: NamespaceConstraint, charge: WildcardCharge): NamespaceConstraint;
+export declare function wildcardNamespaces(wildcard: Wildcard, charge?: WildcardCharge): NamespaceConstraint;
+export declare function namespaceAllows(value: NamespaceConstraint, namespace: string, charge?: WildcardCharge): boolean;
+/** Mathematical inclusion; the XSD Wildcard Subset rule is stricter. */
+export declare function namespaceSetSubset(derived: NamespaceConstraint, base: NamespaceConstraint, charge?: WildcardCharge): boolean;
+/** XSD 1.0 cos-ns-subset: non-any negations must have the same value. */
+export declare function namespaceSubset(derived: NamespaceConstraint, base: NamespaceConstraint, charge?: WildcardCharge): boolean;
+export declare function namespaceUnion(a: NamespaceConstraint, b: NamespaceConstraint, charge?: WildcardCharge): NamespaceConstraint;
+export declare function namespaceIntersection(a: NamespaceConstraint, b: NamespaceConstraint, charge?: WildcardCharge): NamespaceConstraint;
+/** Abstract namespace-property expressibility, not XML syntax representability.
+ * A finite set (including empty), any, or not(namespace/absent) is expressible.
+ * Keep an unexpressible mathematical intersection intact for diagnostics.
+ */
+export declare function namespaceExpressible(value: NamespaceConstraint, charge?: WildcardCharge): boolean;
+/** The ur-type identity exception belongs to the invoking rule, never spelling. */
+export declare function processContentsRestricts(derived: WildcardProcess, base: WildcardProcess, charge?: WildcardCharge): boolean;
+//# sourceMappingURL=wildcardAlgebra.d.ts.map

package/dist/compiler/wildcardAlgebra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wildcardAlgebra.d.ts","sourceRoot":"","sources":["../../src/compiler/wildcardAlgebra.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,qBAAqB,CAAC;AAGlD,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;IAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;CAAC,CAAC,CAAC;AACjG,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,iBAAiB,CAAC,CAAC;AAC1D,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AA8CvD,oFAAoF;AACpF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,mBAAmB,EAAE,MAAM,EAAE,cAAc,GAAG,mBAAmB,CAEpH;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAE,cAAyB,GAAG,mBAAmB,CAmB7G;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,cAAyB,GAAG,OAAO,CAGzH;AAED,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,GAAE,cAAyB,GAAG,OAAO,CAetI;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,GAAE,cAAyB,GAAG,OAAO,CAMnI;AAyBD,wBAAgB,cAAc,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,mBAAmB,EAAE,MAAM,GAAE,cAAyB,GAAG,mBAAmB,CAErI;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,mBAAmB,EAAE,MAAM,GAAE,cAAyB,GAAG,mBAAmB,CAE5I;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,EAAE,MAAM,GAAE,cAAyB,GAAG,OAAO,CAK3G;AAED,mFAAmF;AACnF,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,GAAE,cAAyB,GAAG,OAAO,CAIpI"}

package/dist/compiler/wildcardAlgebra.js

@@ -0,0 +1,155 @@
+import { SemanticError } from './resolveCanonicalGraph.js';
+// Compatibility callers may already account for work; new semantic callers
+// pass their shared request charge. No semantic receipt or cache is issued here.
+const noCharge = () => { };
+function textEqual(a, b, charge) {
+    charge(1 + a.length + b.length);
+    return a === b;
+}
+function contains(values, value, charge) {
+    charge();
+    for (const item of values) {
+        charge();
+        if (textEqual(item, value, charge))
+            return true;
+    }
+    return false;
+}
+/** Deterministic insertion avoids an engine-dependent uncharged sort. */
+function canonical(values, charge) {
+    charge();
+    const result = [];
+    for (const value of values) {
+        charge();
+        let at = 0;
+        while (at < result.length) {
+            charge(1 + value.length + result[at].length);
+            if (value <= result[at])
+                break;
+            at++;
+        }
+        if (at < result.length && textEqual(value, result[at], charge))
+            continue;
+        charge(1 + result.length - at); // Entry and shifts, before allocation/mutation.
+        result.splice(at, 0, value);
+    }
+    charge(result.length + 1);
+    return Object.freeze(result);
+}
+function constraint(kind, values, charge) {
+    const namespaces = canonical(values, charge);
+    charge(4);
+    return Object.freeze({ kind, namespaces });
+}
+/** Canonical mathematical namespace properties; no XML lexical form is invented. */
+export function canonicalNamespaceConstraint(value, charge) {
+    return constraint(value.kind, value.namespaces, charge);
+}
+export function wildcardNamespaces(wildcard, charge = noCharge) {
+    const raw = wildcard.namespace.value;
+    charge(4 * raw.length + 4); // Scans and token/text output before regex/split.
+    const value = raw.replace(/^[\x20\t\r\n]+|[\x20\t\r\n]+$/g, '');
+    const namespace = wildcard.namespace.context.effectiveNamespace;
+    if (value === '##any')
+        return constraint('not', [], charge);
+    if (value === '##other')
+        return constraint('not', ['', namespace], charge);
+    const tokens = value.split(/[\x20\t\r\n]+/);
+    charge(tokens.length + 1);
+    const values = [];
+    for (const token of tokens) {
+        charge(token.length + 3);
+        if (!token || token.startsWith('##') && token !== '##local' && token !== '##targetNamespace') {
+            throw new SemanticError('invalid-schema', 'Invalid wildcard namespace constraint', undefined, wildcard.namespace.context.source);
+        }
+        charge();
+        values.push(token === '##local' ? '' : token === '##targetNamespace' ? namespace : token);
+    }
+    return constraint('set', values, charge);
+}
+export function namespaceAllows(value, namespace, charge = noCharge) {
+    const present = contains(value.namespaces, namespace, charge);
+    return value.kind === 'set' ? present : !present;
+}
+/** Mathematical inclusion; the XSD Wildcard Subset rule is stricter. */
+export function namespaceSetSubset(derived, base, charge = noCharge) {
+    charge();
+    if (derived.kind === 'set') {
+        for (const namespace of derived.namespaces) {
+            charge();
+            if (!namespaceAllows(base, namespace, charge))
+                return false;
+        }
+        return true;
+    }
+    if (base.kind === 'set')
+        return false; // A cofinite set cannot fit a finite one.
+    for (const namespace of base.namespaces) {
+        charge();
+        if (!contains(derived.namespaces, namespace, charge))
+            return false;
+    }
+    return true;
+}
+/** XSD 1.0 cos-ns-subset: non-any negations must have the same value. */
+export function namespaceSubset(derived, base, charge = noCharge) {
+    charge();
+    if (base.kind === 'not' && base.namespaces.length === 0)
+        return true;
+    if (derived.kind === 'set')
+        return namespaceSetSubset(derived, base, charge);
+    if (base.kind !== 'not')
+        return false;
+    return namespaceSetSubset(derived, base, charge) && namespaceSetSubset(base, derived, charge);
+}
+function combine(a, b, union, charge) {
+    charge();
+    const values = [];
+    const append = (value) => { charge(); values.push(value); };
+    if (a.kind === b.kind) {
+        const concatenate = union === (a.kind === 'set');
+        for (const value of a.namespaces) {
+            charge();
+            if (concatenate || contains(b.namespaces, value, charge))
+                append(value);
+        }
+        if (concatenate)
+            for (const value of b.namespaces) {
+                charge();
+                append(value);
+            }
+        return constraint(a.kind, values, charge);
+    }
+    const excluded = a.kind === 'not' ? a : b;
+    const included = a.kind === 'set' ? a : b;
+    const from = union ? excluded : included, subtract = union ? included : excluded;
+    for (const value of from.namespaces) {
+        charge();
+        if (!contains(subtract.namespaces, value, charge))
+            append(value);
+    }
+    return constraint(union ? 'not' : 'set', values, charge);
+}
+export function namespaceUnion(a, b, charge = noCharge) {
+    return combine(a, b, true, charge);
+}
+export function namespaceIntersection(a, b, charge = noCharge) {
+    return combine(a, b, false, charge);
+}
+/** Abstract namespace-property expressibility, not XML syntax representability.
+ * A finite set (including empty), any, or not(namespace/absent) is expressible.
+ * Keep an unexpressible mathematical intersection intact for diagnostics.
+ */
+export function namespaceExpressible(value, charge = noCharge) {
+    charge();
+    if (value.kind === 'set')
+        return true;
+    const excluded = canonical(value.namespaces, charge);
+    return excluded.length === 0 || excluded.length <= 2 && contains(excluded, '', charge);
+}
+/** The ur-type identity exception belongs to the invoking rule, never spelling. */
+export function processContentsRestricts(derived, base, charge = noCharge) {
+    charge();
+    const rank = { skip: 0, lax: 1, strict: 2 };
+    return rank[derived] >= rank[base];
+}

package/dist/gateway/generateGateway.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateGateway.d.ts","sourceRoot":"","sources":["../../src/gateway/generateGateway.ts"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,sBAAsB;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,0BAA0B,CAAC,EAAE,MAAM,EAAE,CAAC;IACtC,OAAO,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;IAE/B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8JjF"}
+{"version":3,"file":"generateGateway.d.ts","sourceRoot":"","sources":["../../src/gateway/generateGateway.ts"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,sBAAsB;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,0BAA0B,CAAC,EAAE,MAAM,EAAE,CAAC;IACtC,OAAO,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;IAE/B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6JjF"}

package/dist/gateway/generateGateway.js

@@ -21,6 +21,7 @@
  *     routes.ts      - Route registration module
  */
 import fs from "node:fs";
+import { readLegacyCatalogFile } from "../compiler/semanticCatalog.js";
 import path from "node:path";
 import * as yaml from "js-yaml";
 import { buildParamSchemasForOperation, getJsonSchemaRefName, isNumericStatus, resolveClientMeta, resolveOperationMeta, } from "./helpers.js";
@@ -126,8 +127,7 @@ export async function generateGateway(opts) {
     // Load catalog if provided (for operation metadata)
     let catalog = undefined;
     if (opts.catalogFile && fs.existsSync(opts.catalogFile)) {
-        const catalogRaw = fs.readFileSync(opts.catalogFile, "utf8");
-        catalog = JSON.parse(catalogRaw);
+        catalog = readLegacyCatalogFile(opts.catalogFile);
     }
     // Resolve client metadata for full handler generation
     const clientMeta = resolveClientMeta({

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export { generateTests } from "./test/generateTests.js";
 export { runGenerationPipeline } from "./pipeline.js";
 export { loadStreamConfigFile, parseStreamConfig, StreamConfigError, type OperationStreamMetadata, type ShapeCatalogRef, type StreamConfig, } from "./util/streamConfig.js";
 export { applyShapeCatalogs, type ApplyShapeCatalogsOptions } from "./compiler/shapeResolver.js";
+export { checkedDirectRuntimeV1 } from './client/checkedDirectRuntime.js';
 /**
  * Compiles a WSDL file to TypeScript client code
  *
@@ -35,4 +36,6 @@ export declare function compileWsdlToProject(input: {
     /** In-memory stream configuration. Ignored when `streamConfigFile` is set. */
     streamConfig?: import("./util/streamConfig.js").StreamConfig;
 }): Promise<void>;
+export { assessSchemaSource, serializeAssessmentReport, parseAssessmentReport, assessmentExitCode, ASSESSMENT_VERSION, ASSESSMENT_BASIS } from './compiler/checkedAssessment.js';
+export type { CheckedAssessmentReport, AssessmentObligation, AssessedOperation, AssessmentStatus } from './compiler/checkedAssessment.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,aAAa,CAAC;AAWjD,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,cAAc,GACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAC,aAAa,EAAC,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAC,qBAAqB,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACpB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAC,kBAAkB,EAAE,KAAK,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AAG/F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE;IACL,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,kHAAkH;IAClH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,YAAY,CAAC,EAAE,OAAO,wBAAwB,EAAE,YAAY,CAAC;CAC9D,GACA,OAAO,CAAC,IAAI,CAAC,CA2Ef"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,aAAa,CAAC;AAWjD,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,cAAc,GACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAC,aAAa,EAAC,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAC,qBAAqB,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACpB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAC,kBAAkB,EAAE,KAAK,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AAC/F,OAAO,EAAC,sBAAsB,EAAC,MAAM,kCAAkC,CAAC;AAGxE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE;IACL,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,kHAAkH;IAClH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,YAAY,CAAC,EAAE,OAAO,wBAAwB,EAAE,YAAY,CAAC;CAC9D,GACA,OAAO,CAAC,IAAI,CAAC,CA2Ef;AAED,OAAO,EAAC,kBAAkB,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,gBAAgB,EAAC,MAAM,iCAAiC,CAAC;AAC/K,YAAY,EAAC,uBAAuB,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,gBAAgB,EAAC,MAAM,iCAAiC,CAAC"}

package/dist/index.js

@@ -29,6 +29,7 @@ export { generateTests } from "./test/generateTests.js";
 export { runGenerationPipeline } from "./pipeline.js";
 export { loadStreamConfigFile, parseStreamConfig, StreamConfigError, } from "./util/streamConfig.js";
 export { applyShapeCatalogs } from "./compiler/shapeResolver.js";
+export { checkedDirectRuntimeV1 } from './client/checkedDirectRuntime.js';
 // noinspection JSUnusedGlobalSymbols
 /**
  * Compiles a WSDL file to TypeScript client code
@@ -117,3 +118,4 @@ export async function compileWsdlToProject(input) {
         generateCatalog(catalogFile, compiled);
     }
 }
+export { assessSchemaSource, serializeAssessmentReport, parseAssessmentReport, assessmentExitCode, ASSESSMENT_VERSION, ASSESSMENT_BASIS } from './compiler/checkedAssessment.js';