@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/structuralCompanions.js

@@ -0,0 +1,232 @@
+/** Required structural closures over one declared graph; no public-symbol renaming. */
+import { deepFreeze, globalId } from "./canonicalGraph.js";
+import { containedNodes, referenceSlots, mapNodeReferences } from "./graphTraversal.js";
+import { referenceTarget, SemanticError, semanticBudget, countSemanticData } from "./resolveCanonicalGraph.js";
+import { semanticGraphRepresentation } from "./catalogProvenance.js";
+import { canonicalJson } from "./catalogErrors.js";
+export function mergeStructuralCompanions(primary, companions, limits = {}) {
+    const budget = semanticBudget(limits);
+    if (primary.nodes.length > budget.maxNodes)
+        throw new SemanticError("resource-limit", `Primary input exceeds ${budget.maxNodes} graph nodes`);
+    const nodes = new Map(primary.nodes.map(n => { budget.step(n); return [n.id, n]; }));
+    const checkSize = () => { if (nodes.size > budget.maxNodes)
+        throw new SemanticError("resource-limit", `Companion graph exceeds ${budget.maxNodes} nodes`); };
+    checkSize();
+    // Bound normalization and provenance copying before recursive serialization allocates.
+    const countData = (value, node) => countSemanticData(value, budget, node);
+    const owned = (root, index) => {
+        const stack = [root.id], seen = new Set(), result = [];
+        while (stack.length) {
+            const id = stack.pop();
+            if (seen.has(id))
+                continue;
+            const node = index.get(id);
+            if (!node)
+                throw new SemanticError("invalid-schema", `Missing owned component ${id}`, root.id, root.context.source);
+            budget.step(node);
+            seen.add(id);
+            result.push(node);
+            for (const child of containedNodes(node)) {
+                budget.step(node);
+                stack.push(child);
+            }
+            for (const slot of referenceSlots(node))
+                if (slot.reference.kind === "local") {
+                    budget.step(node);
+                    stack.push(slot.reference.target);
+                }
+        }
+        return result;
+    };
+    const representation = (root, index) => {
+        const declarations = owned(root, index);
+        countData(declarations, root);
+        return semanticGraphRepresentation({ ...primary, nodes: declarations, globals: [root.id], origins: {}, schemaAnnotations: [], schemaRetained: [], loading: { ...primary.loading, edges: [] } }, { referenceIdentityOnly: true });
+    };
+    const origins = Object.create(null), originKeys = new Map();
+    const addOrigins = (id, values, node) => {
+        const list = origins[id] ??= [], keys = originKeys.get(id) ?? new Set();
+        originKeys.set(id, keys);
+        for (const origin of values) {
+            countData(origin, node);
+            const key = canonicalJson(origin);
+            if (!keys.has(key)) {
+                keys.add(key);
+                list.push(origin);
+            }
+        }
+    };
+    for (const node of primary.nodes) {
+        budget.step(node);
+        addOrigins(node.id, primary.origins[node.id] ?? [], node);
+    }
+    const edges = [...primary.loading.edges], retained = [...primary.schemaRetained], annotations = [...primary.schemaAnnotations];
+    countData([edges, retained, annotations]);
+    const edgeKeys = new Set(edges.map(canonicalJson)), retainedKeys = new Set(retained.map(canonicalJson)), annotationKeys = new Set(annotations.map(canonicalJson));
+    const copied = new Set(), deduplicated = new Set();
+    // Index requested pools before walking, so a cross-companion dependency is
+    // resolved by availability rather than the caller's request order.
+    const providers = new Map();
+    const pools = companions.map((companion, pool) => {
+        budget.step();
+        if (companion.graph.nodes.length > budget.maxNodes)
+            throw new SemanticError("resource-limit", `Companion input exceeds ${budget.maxNodes} graph nodes`);
+        const source = new Map(companion.graph.nodes.map(n => { budget.step(n); return [n.id, n]; }));
+        if (companion.roots.length)
+            for (const node of source.values()) {
+                budget.step(node);
+                if (node.identity.kind !== "global")
+                    continue;
+                const available = providers.get(node.id) ?? [];
+                available.push(pool);
+                providers.set(node.id, available);
+            }
+        return { companion, source, selected: new Set() };
+    });
+    const queue = [];
+    const enqueueAvailable = (id, node) => {
+        for (const pool of providers.get(id) ?? []) {
+            budget.step(node);
+            queue.push({ pool, id });
+        }
+    };
+    pools.forEach(({ companion, source }, pool) => {
+        for (const root of companion.roots) {
+            budget.step();
+            const node = source.get(root);
+            if (!node || node.identity.kind !== "global")
+                throw new SemanticError("invalid-schema", `Companion root must identify a declared global component: ${root}`, root, node?.context.source);
+            queue.push({ pool, id: root });
+        }
+    });
+    for (const node of primary.nodes)
+        for (const { reference } of referenceSlots(node)) {
+            budget.step(node);
+            if (reference.kind === "symbol") {
+                const id = globalId(reference.role, reference.name);
+                if (!nodes.has(id))
+                    enqueueAvailable(id, node);
+            }
+        }
+    while (queue.length) {
+        const { pool, id } = queue.pop(), { source, selected } = pools[pool];
+        if (selected.has(id))
+            continue;
+        const node = source.get(id);
+        if (!node)
+            throw new SemanticError("invalid-schema", `Missing companion component ${id}`, id);
+        budget.step(node);
+        selected.add(id);
+        for (const child of containedNodes(node)) {
+            budget.step(node);
+            queue.push({ pool, id: child });
+        }
+        for (const { reference } of referenceSlots(node)) {
+            budget.step(node);
+            const candidate = reference.kind === "local" ? reference.target : reference.kind === "symbol" ? globalId(reference.role, reference.name) : undefined;
+            if (candidate && source.has(candidate)) {
+                referenceTarget(reference, source, node);
+                queue.push({ pool, id: candidate });
+            }
+            else if (candidate && reference.kind === "symbol" && !nodes.has(candidate) && providers.has(candidate)) {
+                for (const available of providers.get(candidate))
+                    referenceTarget(reference, pools[available].source, node);
+                enqueueAvailable(candidate, node);
+            }
+            else
+                referenceTarget(reference, nodes, node);
+        }
+    }
+    for (const { companion, source, selected } of pools) {
+        const interpretations = new Set(), contexts = new Set(), documents = new Set();
+        for (const id of selected) {
+            const node = source.get(id);
+            for (const origin of companion.graph.origins[id] ?? []) {
+                countData(origin, node);
+                interpretations.add(origin.interpretation);
+                contexts.add(canonicalJson([origin.context.source.uri, origin.context.source.digest, origin.context.effectiveNamespace]));
+                documents.add(canonicalJson([origin.context.source.uri, origin.context.source.digest]));
+            }
+        }
+        const mapping = new Map();
+        for (const id of [...selected].sort((a, b) => { budget.step(); return a < b ? -1 : a > b ? 1 : 0; })) {
+            const root = source.get(id);
+            if (root.identity.kind !== "global")
+                continue;
+            const current = nodes.get(id);
+            if (current) {
+                const a = representation(current, nodes), b = representation(root, source);
+                if (a.structure !== b.structure)
+                    throw new SemanticError("invalid-schema", `Structural companion collision for ${id}; reconcile the original declarations`, id, root.context.source, [current.context.source]);
+                // Equal normalized positions identify corresponding scoped declarations.
+                const positions = new Map([...a.identities].map(([original, normalized]) => [normalized, original]));
+                for (const [original, normalized] of b.identities) {
+                    budget.step(root);
+                    mapping.set(original, positions.get(normalized));
+                }
+                deduplicated.add(id);
+            }
+            else {
+                for (const node of owned(root, source)) {
+                    budget.step(node);
+                    nodes.set(node.id, node);
+                    checkSize();
+                    mapping.set(node.id, node.id);
+                }
+                copied.add(id);
+            }
+        }
+        for (const id of selected) {
+            const target = mapping.get(id), node = source.get(id);
+            if (!target)
+                throw new SemanticError("invalid-schema", "Companion closure lost scoped ownership", id, node.context.source);
+            addOrigins(target, companion.graph.origins[id] ?? [], node);
+        }
+        for (const edge of companion.graph.loading.edges) {
+            budget.step();
+            if (!interpretations.has(edge.from))
+                continue;
+            countData(edge);
+            const key = canonicalJson(edge);
+            if (!edgeKeys.has(key)) {
+                edgeKeys.add(key);
+                edges.push(edge);
+            }
+        }
+        for (const entry of companion.graph.schemaRetained) {
+            budget.step();
+            if (!contexts.has(canonicalJson([entry.context.source.uri, entry.context.source.digest, entry.context.effectiveNamespace])))
+                continue;
+            countData(entry);
+            const key = canonicalJson(entry);
+            if (!retainedKeys.has(key)) {
+                retainedKeys.add(key);
+                retained.push(entry);
+            }
+        }
+        for (const annotation of companion.graph.schemaAnnotations) {
+            budget.step();
+            if (!documents.has(canonicalJson([annotation.source.uri, annotation.source.digest])))
+                continue;
+            countData(annotation);
+            const key = canonicalJson(annotation);
+            if (!annotationKeys.has(key)) {
+                annotationKeys.add(key);
+                annotations.push(annotation);
+            }
+        }
+    }
+    const linked = [...nodes.values()].map(node => {
+        budget.step(node);
+        return mapNodeReferences(node, reference => {
+            budget.step(node);
+            if (reference.kind !== "symbol")
+                return reference;
+            const id = globalId(reference.role, reference.name);
+            if (reference.target !== undefined && reference.target !== id)
+                throw new SemanticError("invalid-schema", "Stored companion reference has a mismatched target", node.id, reference.lexical.context.source);
+            return nodes.has(id) ? { ...reference, target: id } : reference;
+        });
+    }).sort((a, b) => { budget.step(); return a.id < b.id ? -1 : a.id > b.id ? 1 : 0; });
+    return deepFreeze({ graph: { ...primary, nodes: linked, globals: linked.filter(n => n.identity.kind === "global").map(n => n.id).sort(), origins, schemaAnnotations: annotations, schemaRetained: retained, loading: { ...primary.loading, edges } }, copied: [...copied].sort(), deduplicated: [...deduplicated].sort(), metrics: { steps: budget.steps } });
+}

package/dist/compiler/validateSemanticGraph.d.ts

@@ -0,0 +1,4 @@
+import type { CanonicalGraph } from "./canonicalGraph.js";
+export declare function validateSemanticGraph(input: unknown, options?: {
+    maxNodes?: number;
+}): asserts input is CanonicalGraph;

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,25 @@
+/** 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;