@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/buildCanonicalGraph.js

@@ -0,0 +1,381 @@
+/** Pure two-phase construction from the repository-owned S03 adapter; no I/O or expansion. */
+import { resolveLexicalQName, syntaxAttribute, syntaxElements, XSD_NAMESPACE, WSDL_NAMESPACE } from "../loader/orderedSyntax.js";
+import { DEFAULT_GRAPH_NODES, GRAPH_MODEL, GraphError, globalId, scopedId, deepFreeze, isBuiltinType, wsdlReferenceRoles } from "./canonicalGraph.js";
+import { mapNodeReferences } from "./graphTraversal.js";
+const declarationRoles = Object.assign(Object.create(null), { element: "element", attribute: "attribute", simpleType: "type", complexType: "type", group: "group", attributeGroup: "attributeGroup" });
+const particleKinds = new Set(["sequence", "choice", "all", "element", "group", "any"]);
+const facetKinds = new Set(["enumeration", "pattern", "whiteSpace", "length", "minLength", "maxLength", "minInclusive", "minExclusive", "maxInclusive", "maxExclusive", "totalDigits", "fractionDigits"]);
+export function buildCanonicalGraph(input, options = {}) {
+    let allocated = 0;
+    const chargeText = (text) => options.requestBudget?.chargeWork(64 + text.length * 16);
+    const maxNodes = options.maxNodes ?? DEFAULT_GRAPH_NODES;
+    if (!Number.isSafeInteger(maxNodes) || maxNodes < 1)
+        throw new RangeError("maxNodes must be a positive safe integer");
+    // Precharge the source-sized reservation/indexing scans independently of source preparation.
+    options.requestBudget?.freeze(input);
+    const nodes = new Map();
+    const scopedRoles = new Map();
+    const reserved = new Map();
+    const origins = Object.create(null);
+    const annotations = [];
+    const schemaRetained = [];
+    const fail = (node, message) => { throw new GraphError("invalid-schema", message, node.source); };
+    const elementOnly = (node) => {
+        if (node.children.some(c => c.kind === "text" && /[^\t\r\n ]/.test(c.value)))
+            fail(node, "Non-whitespace text in element-only schema content");
+    };
+    const context = (node, schema) => {
+        options.requestBudget?.freeze(node);
+        chargeText(node.source.uri);
+        chargeText(node.source.path);
+        chargeText(node.baseUri);
+        chargeText(schema.targetNamespace);
+        for (const [prefix, namespace] of Object.entries(node.namespaces)) {
+            chargeText(prefix);
+            chargeText(namespace);
+        }
+        return ({ namespaces: node.namespaces, baseUri: node.baseUri, source: node.source,
+            effectiveNamespace: schema.targetNamespace, chameleon: schema.context.kind === "include" && !syntaxAttribute(schema.syntax, "targetNamespace"), schemaAttributes: schema.syntax.attributes });
+    };
+    const lexical = (value, node, scope) => { chargeText(value); return { value, context: context(node, scope.schema) }; };
+    const required = (node, name) => syntaxAttribute(node, name) ?? fail(node, `Missing ${name} attribute`);
+    const bool = (node, name, fallback = false) => {
+        const v = syntaxAttribute(node, name);
+        if (v === undefined)
+            return fallback;
+        if (["true", "1"].includes(v.trim()))
+            return true;
+        if (["false", "0"].includes(v.trim()))
+            return false;
+        return fail(node, `Invalid ${name} boolean`);
+    };
+    const choice = (node, attr, allowed, fallback) => {
+        const value = syntaxAttribute(node, attr)?.trim() ?? fallback;
+        if (!allowed.includes(value))
+            return fail(node, `Invalid ${attr} value`);
+        return value;
+    };
+    const named = (node, namespace) => {
+        const local = required(node, "name");
+        chargeText(local);
+        chargeText(namespace);
+        // Validate NCName through the adapter without letting the default namespace define identity.
+        const resolved = resolveLexicalQName(local, node);
+        if (local.includes(":"))
+            return fail(node, "Declaration name must be an NCName");
+        return { namespace, local: resolved.local };
+    };
+    const occurrence = (node) => {
+        const finite = (v) => {
+            const trimmed = v.trim();
+            if (!/^[+-]?\d+$/.test(trimmed))
+                return fail(node, "Occurrence must be a nonnegative integer");
+            const canonical = trimmed.replace(/^[+-]/, "").replace(/^0+(?=\d)/, "");
+            if (trimmed.startsWith("-") && canonical !== "0")
+                return fail(node, "Occurrence must be a nonnegative integer");
+            return canonical;
+        };
+        const min = finite(syntaxAttribute(node, "minOccurs") ?? "1");
+        const rawMax = syntaxAttribute(node, "maxOccurs")?.trim() ?? "1";
+        const max = rawMax === "unbounded" ? rawMax : finite(rawMax);
+        if (max !== "unbounded" && (min.length > max.length || (min.length === max.length && min > max)))
+            return fail(node, "Occurrence minimum exceeds maximum");
+        return { min, max };
+    };
+    const ref = (value, role, node, scope) => {
+        chargeText(value);
+        const lexicalName = resolveLexicalQName(value, node);
+        // XSD chameleon adoption changes component interpretation, never lexical namespace bindings.
+        const name = !lexicalName.namespace && context(node, scope.schema).chameleon
+            ? { namespace: scope.schema.targetNamespace, local: lexicalName.local } : lexicalName;
+        if (role === "type" && name.namespace === XSD_NAMESPACE && isBuiltinType(name.local))
+            return { kind: "builtin", name, lexical: lexical(value, node, scope) };
+        return { kind: "symbol", role, name, lexical: lexical(value, node, scope) };
+    };
+    const builtin = (local) => ({ kind: "builtin", name: { namespace: XSD_NAMESPACE, local } });
+    const idFor = (node, scope, role) => {
+        chargeText(node.source.path);
+        chargeText(scope.owner);
+        chargeText(scope.rootPath);
+        const id = scopedId(scope.owner, node.source.path.slice(scope.rootPath.length) || "/", role);
+        scopedRoles.set(id, role);
+        return id;
+    };
+    const base = (node, scope, id, identity, consumed = []) => {
+        if (allocated >= maxNodes)
+            throw new GraphError("resource-limit", `Canonical graph exceeds ${maxNodes} nodes`, node.source);
+        options.requestBudget?.reserveNodes(1);
+        allocated += 1;
+        // Retained syntax/namespaces are charged before constructing the record.
+        options.requestBudget?.freeze(node);
+        if (node.name.namespace === XSD_NAMESPACE)
+            elementOnly(node);
+        return { id,
+            identity: identity ?? { kind: "scoped", owner: scope.owner, path: node.source.path.slice(scope.rootPath.length) || "/", role: scopedRoles.get(id) },
+            context: context(node, scope.schema), declaredAttributes: node.attributes,
+            annotations: syntaxElements(node, XSD_NAMESPACE, "annotation"), syntaxDetails: [],
+            retained: syntaxElements(node).filter(c => c.name.namespace !== XSD_NAMESPACE || (c.name.local !== "annotation" && !consumed.includes(c.name.local))) };
+    };
+    const put = (node, scope) => {
+        options.requestBudget?.chargeWork(1024);
+        if (nodes.has(node.id))
+            throw new GraphError("invalid-schema", "Duplicate scoped graph identity", node.context.source);
+        if (nodes.size >= maxNodes)
+            throw new GraphError("resource-limit", `Canonical graph exceeds ${maxNodes} nodes`, node.context.source);
+        nodes.set(node.id, node);
+        origins[node.id] = [{ interpretation: scope.schema.key, context: node.context }];
+        return node.id;
+    };
+    const valueConstraint = (node, scope) => {
+        const d = syntaxAttribute(node, "default"), f = syntaxAttribute(node, "fixed");
+        if (d !== undefined && f !== undefined)
+            return fail(node, "Default and fixed are mutually exclusive");
+        return d !== undefined ? { kind: "default", lexical: lexical(d, node, scope) } : f !== undefined ? { kind: "fixed", lexical: lexical(f, node, scope) } : undefined;
+    };
+    const facets = (node, scope) => syntaxElements(node, XSD_NAMESPACE).filter(n => facetKinds.has(n.name.local)).map(n => ({ name: n.name.local,
+        lexical: lexical(required(n, "value"), n, scope), fixed: bool(n, "fixed"), syntax: n }));
+    const wildcard = (node, scope) => ({ namespace: lexical(syntaxAttribute(node, "namespace") ?? "##any", node, scope),
+        processContents: choice(node, "processContents", ["strict", "lax", "skip"], "strict") });
+    const one = (nodes, node, description) => {
+        if (nodes.length > 1)
+            return fail(node, `Multiple ${description}`);
+        return nodes[0];
+    };
+    const typeFor = (node, scope, fallback) => {
+        const type = syntaxAttribute(node, "type");
+        const inline = one(syntaxElements(node, XSD_NAMESPACE).filter(c => ["simpleType", "complexType"].includes(c.name.local)), node, "inline types");
+        if (type && inline)
+            return fail(node, "Named and inline types are mutually exclusive");
+        return type !== undefined ? ref(type, "type", node, scope) : inline ? { kind: "local", target: buildType(inline, scope) } : builtin(fallback);
+    };
+    const declaration = (node, scope, role, global) => {
+        if (syntaxAttribute(node, "ref") !== undefined)
+            return fail(node, "Reference is a use, not a declaration");
+        if (global && (syntaxAttribute(node, "minOccurs") !== undefined || syntaxAttribute(node, "maxOccurs") !== undefined || syntaxAttribute(node, "form") !== undefined))
+            return fail(node, "Global declarations cannot carry occurrence or form");
+        const form = choice(node, "form", ["qualified", "unqualified"], choice(scope.schema.syntax, role === "element" ? "elementFormDefault" : "attributeFormDefault", ["qualified", "unqualified"], "unqualified"));
+        const name = named(node, global || form === "qualified" ? scope.schema.targetNamespace : "");
+        const id = global ? globalId(role, name) : idFor(node, scope, role);
+        const inner = { schema: scope.schema, owner: id, rootPath: node.source.path };
+        const common = { ...base(node, scope, id, global, ["simpleType", "complexType"]), name, type: typeFor(node, inner, role === "element" ? "anyType" : "anySimpleType"), value: valueConstraint(node, scope) };
+        if (role === "attribute") {
+            if (syntaxElements(node, XSD_NAMESPACE, "complexType").length)
+                return fail(node, "Attributes require simple types");
+            return put({ ...common, kind: "attribute" }, scope);
+        }
+        const sg = syntaxAttribute(node, "substitutionGroup");
+        return put({ ...common, kind: "element", nillable: bool(node, "nillable"), abstract: bool(node, "abstract"), substitutionGroup: sg === undefined ? undefined : ref(sg, "element", node, scope) }, scope);
+    };
+    const particle = (node, scope) => {
+        const id = idFor(node, scope, "particle"), occurs = occurrence(node);
+        const common = { ...base(node, scope, id, undefined, ["sequence", "choice", "all", "element", "group", "any"]), kind: "particle", occurs };
+        const kind = node.name.local;
+        if (["sequence", "choice", "all"].includes(kind)) {
+            const children = syntaxElements(node, XSD_NAMESPACE).filter(c => particleKinds.has(c.name.local));
+            if (children.some(c => c.name.local === "all"))
+                return fail(node, "XSD 1.0 all cannot be nested inside a compositor");
+            if (kind === "all" && (occurs.max !== "1" || !["0", "1"].includes(occurs.min)))
+                return fail(node, "XSD 1.0 all requires min 0/1 and max 1");
+            if (kind === "all" && children.some(c => c.name.local !== "element" || !["0", "1"].includes(occurrence(c).min) || !["0", "1"].includes(occurrence(c).max)))
+                return fail(node, "XSD 1.0 all children must be elements with 0/1 bounds");
+            return put({ ...common, term: { kind: kind, children: children.map(c => particle(c, scope)) } }, scope);
+        }
+        if (kind === "any")
+            return put({ ...common, term: { kind: "any", wildcard: wildcard(node, scope) } }, scope);
+        if (kind === "group") {
+            if (syntaxAttribute(node, "name") !== undefined || syntaxElements(node, XSD_NAMESPACE).some(c => particleKinds.has(c.name.local)))
+                return fail(node, "Group uses require only a reference");
+            return put({ ...common, term: { kind: "group", reference: ref(required(node, "ref"), "group", node, scope) } }, scope);
+        }
+        const r = syntaxAttribute(node, "ref");
+        if (r !== undefined && ["name", "type", "form", "default", "fixed", "nillable"].some(a => syntaxAttribute(node, a) !== undefined))
+            return fail(node, "Element references cannot redeclare their target");
+        if (r !== undefined && syntaxElements(node, XSD_NAMESPACE).some(c => c.name.local !== "annotation"))
+            return fail(node, "Element references cannot contain declarations");
+        return put({ ...common, term: { kind: "element", declaration: r !== undefined ? ref(r, "element", node, scope) : { kind: "local", target: declaration(node, scope, "element") } } }, scope);
+    };
+    const attributes = (node, scope) => syntaxElements(node, XSD_NAMESPACE).filter(c => ["attribute", "attributeGroup", "anyAttribute"].includes(c.name.local)).map(c => {
+        const id = idFor(c, scope, "attributeUse"), common = base(c, scope, id, undefined, ["simpleType"]);
+        if (c.name.local === "anyAttribute")
+            return put({ ...common, kind: "attributeWildcard", wildcard: wildcard(c, scope) }, scope);
+        if (c.name.local === "attributeGroup")
+            return put({ ...common, kind: "attributeGroupUse", reference: ref(required(c, "ref"), "attributeGroup", c, scope) }, scope);
+        const r = syntaxAttribute(c, "ref");
+        if (r !== undefined && ["name", "type", "form"].some(a => syntaxAttribute(c, a) !== undefined))
+            return fail(c, "Attribute references cannot redeclare their target");
+        if (r !== undefined && syntaxElements(c, XSD_NAMESPACE).some(n => n.name.local !== "annotation"))
+            return fail(c, "Attribute references cannot contain declarations");
+        return put({ ...common, kind: "attributeUse", declaration: r !== undefined ? ref(r, "attribute", c, scope) : { kind: "local", target: declaration(c, scope, "attribute") },
+            use: choice(c, "use", ["optional", "required", "prohibited"], "optional"), value: valueConstraint(c, scope) }, scope);
+    });
+    const buildType = (node, scope, global) => {
+        const id = global?.kind === "global" ? globalId("type", global.name) : idFor(node, scope, "type");
+        const inner = { schema: scope.schema, owner: id, rootPath: node.source.path };
+        const inlineSimple = (container) => {
+            const inline = one(syntaxElements(container, XSD_NAMESPACE, "simpleType"), container, "inline simple types");
+            return inline ? { kind: "local", target: buildType(inline, inner) } : undefined;
+        };
+        if (node.name.local === "simpleType") {
+            const body = one(syntaxElements(node, XSD_NAMESPACE).filter(c => ["restriction", "list", "union"].includes(c.name.local)), node, "simple type varieties") ?? fail(node, "Simple type requires restriction, list or union");
+            elementOnly(body);
+            const common = { ...base(node, scope, id, global, ["restriction", "list", "union"]), kind: "simpleType",
+                annotations: [...syntaxElements(node, XSD_NAMESPACE, "annotation"), ...syntaxElements(body, XSD_NAMESPACE, "annotation")], syntaxDetails: [body],
+                retained: [...syntaxElements(node).filter(c => c.name.namespace !== XSD_NAMESPACE || !["annotation", "restriction", "list", "union"].includes(c.name.local)),
+                    ...syntaxElements(body).filter(c => c.name.namespace !== XSD_NAMESPACE || !["annotation", "simpleType", ...(body.name.local === "restriction" ? [...facetKinds] : [])].includes(c.name.local))] };
+            if (body.name.local === "union") {
+                const members = (syntaxAttribute(body, "memberTypes")?.trim().split(/\s+/).filter(Boolean) ?? []).map(v => ref(v, "type", body, inner));
+                for (const c of syntaxElements(body, XSD_NAMESPACE, "simpleType"))
+                    members.push({ kind: "local", target: buildType(c, inner) });
+                if (!members.length)
+                    return fail(body, "Union requires members");
+                return put({ ...common, variety: { kind: "union", members } }, scope);
+            }
+            const attr = body.name.local === "list" ? "itemType" : "base";
+            const value = syntaxAttribute(body, attr), inline = inlineSimple(body);
+            if (value !== undefined && inline)
+                return fail(body, "Named and inline scalar references are mutually exclusive");
+            const reference = value !== undefined ? ref(value, "type", body, inner) : inline ?? fail(body, `Missing ${attr} or inline type`);
+            return put({ ...common, variety: body.name.local === "list" ? { kind: "list", item: reference } : { kind: "restriction", base: reference, facets: facets(body, inner) } }, scope);
+        }
+        const wrapper = one(syntaxElements(node, XSD_NAMESPACE).filter(c => ["simpleContent", "complexContent"].includes(c.name.local)), node, "content wrappers");
+        const body = wrapper ? one(syntaxElements(wrapper, XSD_NAMESPACE).filter(c => ["extension", "restriction"].includes(c.name.local)), wrapper, "derivations") ?? fail(wrapper, "Missing content derivation") : node;
+        if (wrapper) {
+            elementOnly(wrapper);
+            elementOnly(body);
+        }
+        if (wrapper && syntaxElements(node, XSD_NAMESPACE).some(c => particleKinds.has(c.name.local) || ["attribute", "attributeGroup", "anyAttribute"].includes(c.name.local)))
+            return fail(node, "Content wrappers cannot coexist with direct content");
+        const content = one(syntaxElements(body, XSD_NAMESPACE).filter(c => particleKinds.has(c.name.local)), body, "content particles");
+        if (content && !["sequence", "choice", "all", "group"].includes(content.name.local))
+            return fail(content, "Complex type content requires a compositor or group reference");
+        if (content && wrapper?.name.local === "simpleContent")
+            return fail(content, "Simple content cannot contain a particle");
+        return put({ ...base(node, scope, id, global, ["simpleContent", "complexContent", "sequence", "choice", "all", "group", "attribute", "attributeGroup", "anyAttribute"]),
+            kind: "complexType", mixed: wrapper ? bool(wrapper, "mixed", bool(node, "mixed")) : bool(node, "mixed"), abstract: bool(node, "abstract"),
+            annotations: [...syntaxElements(node, XSD_NAMESPACE, "annotation"), ...(wrapper ? [...syntaxElements(wrapper, XSD_NAMESPACE, "annotation"), ...syntaxElements(body, XSD_NAMESPACE, "annotation")] : [])],
+            syntaxDetails: wrapper ? [wrapper] : [],
+            retained: [...syntaxElements(node).filter(c => c.name.namespace !== XSD_NAMESPACE || !["annotation", "simpleContent", "complexContent", ...particleKinds, "attribute", "attributeGroup", "anyAttribute"].includes(c.name.local)),
+                ...(wrapper ? [...syntaxElements(wrapper).filter(c => c.name.namespace !== XSD_NAMESPACE || !["annotation", "extension", "restriction"].includes(c.name.local)),
+                    ...syntaxElements(body).filter(c => c.name.namespace !== XSD_NAMESPACE || !["annotation", ...(wrapper.name.local === "simpleContent" && body.name.local === "restriction" ? ["simpleType"] : []), ...particleKinds, ...facetKinds, "attribute", "attributeGroup", "anyAttribute"].includes(c.name.local))] : [])],
+            content: content ? particle(content, inner) : undefined, attributes: attributes(body, inner),
+            derivation: wrapper ? { kind: body.name.local, contentKind: wrapper.name.local === "simpleContent" ? "simple" : "complex",
+                base: ref(required(body, "base"), "type", body, inner), inlineType: wrapper.name.local === "simpleContent" && body.name.local === "restriction" ? inlineSimple(body) : undefined,
+                facets: facets(body, inner) } : undefined }, scope);
+    };
+    // Phase 1: reserve global symbol space, independent of interpretation keys and traversal order.
+    for (const schema of input.schemas) {
+        elementOnly(schema.syntax);
+        annotations.push(...syntaxElements(schema.syntax, XSD_NAMESPACE, "annotation"));
+        for (const child of syntaxElements(schema.syntax)) {
+            if (child.name.namespace !== XSD_NAMESPACE || !["annotation", ...Object.keys(declarationRoles)].includes(child.name.local))
+                schemaRetained.push({ context: context(child, schema), syntax: child });
+        }
+        for (const node of syntaxElements(schema.syntax, XSD_NAMESPACE)) {
+            const role = declarationRoles[node.name.local];
+            if (!role)
+                continue;
+            const name = named(node, schema.targetNamespace), id = globalId(role, name), prior = reserved.get(id);
+            if (prior) {
+                if (prior.node.source.digest !== node.source.digest || prior.node.source.path !== node.source.path)
+                    fail(node, "Conflicting global symbol declarations");
+            }
+            else {
+                if (reserved.size >= maxNodes)
+                    throw new GraphError("resource-limit", `Canonical graph exceeds ${maxNodes} declarations`, node.source);
+                reserved.set(id, { node, schema });
+            }
+        }
+    }
+    // Phase 2: build complete bodies. References are linked afterward, never expanded into stubs.
+    for (const [id, { node, schema }] of reserved) {
+        const scope = { schema, owner: id, rootPath: node.source.path };
+        const role = declarationRoles[node.name.local], identity = { kind: "global", role, name: named(node, schema.targetNamespace) };
+        if (role === "type")
+            buildType(node, scope, identity);
+        else if (role === "element" || role === "attribute")
+            declaration(node, scope, role, identity);
+        else if (role === "group") {
+            const content = one(syntaxElements(node, XSD_NAMESPACE).filter(c => ["sequence", "choice", "all"].includes(c.name.local)), node, "group content") ?? fail(node, "Group requires compositor content");
+            if (syntaxAttribute(content, "minOccurs") !== undefined || syntaxAttribute(content, "maxOccurs") !== undefined)
+                fail(content, "Group definition content cannot carry occurrence bounds");
+            put({ ...base(node, scope, id, identity, ["sequence", "choice", "all"]), kind: "group", content: particle(content, scope) }, scope);
+        }
+        else
+            put({ ...base(node, scope, id, identity, ["attribute", "attributeGroup", "anyAttribute"]), kind: "attributeGroup", attributes: attributes(node, scope) }, scope);
+    }
+    // WSDL references remain ordered and role-qualified for later operation/binding planning.
+    for (const doc of input.documents) {
+        if (doc.root.name.namespace !== WSDL_NAMESPACE)
+            continue;
+        const namespace = syntaxAttribute(doc.root, "targetNamespace") ?? "";
+        const schema = { key: doc.uri, syntax: doc.root, documentUri: doc.uri, digest: doc.digest, baseUri: doc.root.baseUri, targetNamespace: namespace, context: { kind: "root", namespace } };
+        for (const node of syntaxElements(doc.root, WSDL_NAMESPACE).filter(n => ["message", "portType", "binding", "service"].includes(n.name.local))) {
+            const role = node.name.local, name = named(node, namespace), id = globalId(role, name);
+            const scope = { schema, owner: id, rootPath: node.source.path };
+            const references = [];
+            const visit = (n) => {
+                options.requestBudget?.freeze(n);
+                const roles = wsdlReferenceRoles(n);
+                for (const [attribute, targetRole] of Object.entries(roles)) {
+                    const value = syntaxAttribute(n, attribute);
+                    if (value !== undefined)
+                        references.push({ path: n.source.path.slice(node.source.path.length) || "/", attribute, reference: ref(value, targetRole, n, scope) });
+                }
+                for (const c of syntaxElements(n))
+                    visit(c);
+            };
+            visit(node);
+            put({ ...base(node, scope, id, { kind: "global", role, name }), retained: [], kind: "wsdl", role, name, syntax: node, references }, scope);
+        }
+    }
+    const link = (r) => {
+        options.requestBudget?.chargeWork(128);
+        if (r.kind !== "symbol")
+            return r;
+        chargeText(r.name.namespace);
+        chargeText(r.name.local);
+        const target = globalId(r.role, r.name);
+        return { ...r, ...(nodes.has(target) ? { target } : {}) };
+    };
+    const linkNode = (node) => mapNodeReferences(node, link);
+    // All loading contexts remain provenance; they do not multiply global symbols or local bodies.
+    const ownerCache = new Map();
+    const rootOwner = (n) => {
+        options.requestBudget?.chargeWork(64 + n.id.length * 4);
+        if (n.identity.kind === "global")
+            return n.id;
+        const prior = ownerCache.get(n.id);
+        if (prior)
+            return prior;
+        const owner = rootOwner(nodes.get(n.identity.owner));
+        ownerCache.set(n.id, owner);
+        return owner;
+    };
+    const owned = new Map();
+    for (const n of nodes.values()) {
+        const owner = rootOwner(n), group = owned.get(owner) ?? [];
+        group.push(n);
+        owned.set(owner, group);
+    }
+    for (const schema of input.schemas)
+        for (const node of syntaxElements(schema.syntax, XSD_NAMESPACE)) {
+            const role = declarationRoles[node.name.local];
+            if (!role)
+                continue;
+            const id = globalId(role, named(node, schema.targetNamespace));
+            if (!origins[id].some(o => o.interpretation === schema.key)) {
+                const paths = new Map();
+                const visit = (n) => { options.requestBudget?.freeze(n); paths.set(n.source.path, n); for (const c of syntaxElements(n))
+                    visit(c); };
+                visit(node);
+                for (const n of owned.get(id) ?? [])
+                    origins[n.id].push({ interpretation: schema.key, context: context(paths.get(n.context.source.path), schema) });
+            }
+        }
+    const data = [...nodes.values()];
+    const ordered = options.requestBudget ? options.requestBudget.sorted(data, (a, b) => options.requestBudget.compareText(a.id, b.id)) : data.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    const result = { model: GRAPH_MODEL, nodes: ordered.map(linkNode),
+        globals: ordered.filter(n => n.identity.kind === "global").map(n => n.id), origins,
+        schemaAnnotations: annotations, schemaRetained, loading: { limits: input.limits, edges: input.edges } };
+    return options.requestBudget ? options.requestBudget.freeze(result) : deepFreeze(result);
+}

package/dist/compiler/canonicalGraph.d.ts

@@ -0,0 +1,197 @@
+import type { ExpandedName, SyntaxAttribute, SyntaxElement, SyntaxSource } from "../loader/orderedSyntax.js";
+export declare const GRAPH_MODEL: "xsd10-faithful-v1";
+export declare const DEFAULT_GRAPH_NODES = 100000;
+export declare const isBuiltinType: (local: string) => boolean;
+export type NodeId = string;
+export type SymbolRole = "element" | "attribute" | "type" | "group" | "attributeGroup" | "message" | "portType" | "binding" | "service";
+export type Identity = Readonly<{
+    kind: "global";
+    role: SymbolRole;
+    name: ExpandedName;
+} | {
+    kind: "scoped";
+    owner: NodeId;
+    path: string;
+    role: string;
+}>;
+export type GraphContext = Readonly<{
+    namespaces: Readonly<Record<string, string>>;
+    baseUri: string;
+    source: SyntaxSource;
+    effectiveNamespace: string;
+    chameleon: boolean;
+    schemaAttributes: readonly SyntaxAttribute[];
+}>;
+export type LexicalValue = Readonly<{
+    value: string;
+    context: GraphContext;
+}>;
+export type Reference = Readonly<{
+    kind: "symbol";
+    role: SymbolRole;
+    name: ExpandedName;
+    lexical: LexicalValue;
+    target?: NodeId;
+} | {
+    kind: "builtin";
+    name: ExpandedName;
+    lexical?: LexicalValue;
+} | {
+    kind: "local";
+    target: NodeId;
+}>;
+/** Canonical unsigned decimal strings; no Number conversion or derived occurrence summaries. */
+export type Occurs = Readonly<{
+    min: string;
+    max: string | "unbounded";
+}>;
+export type ValueConstraint = Readonly<{
+    kind: "default" | "fixed";
+    lexical: LexicalValue;
+}>;
+export type Facet = Readonly<{
+    name: string;
+    lexical: LexicalValue;
+    fixed: boolean;
+    syntax: SyntaxElement;
+}>;
+export type Wildcard = Readonly<{
+    namespace: LexicalValue;
+    processContents: "strict" | "lax" | "skip";
+}>;
+type NodeBase = Readonly<{
+    id: NodeId;
+    identity: Identity;
+    context: GraphContext;
+    declaredAttributes: readonly SyntaxAttribute[];
+    annotations: readonly SyntaxElement[];
+    /** Unsupported/uninterpreted declarations remain visible for S06 capability assessment. */
+    retained: readonly SyntaxElement[];
+    /** Ordered restriction/list/union or content-wrapper syntax, including unassessed attributes. */
+    syntaxDetails: readonly SyntaxElement[];
+}>;
+export type ElementNode = NodeBase & Readonly<{
+    kind: "element";
+    name: ExpandedName;
+    type: Reference;
+    nillable: boolean;
+    abstract: boolean;
+    value?: ValueConstraint;
+    substitutionGroup?: Reference;
+}>;
+export type AttributeNode = NodeBase & Readonly<{
+    kind: "attribute";
+    name: ExpandedName;
+    type: Reference;
+    value?: ValueConstraint;
+}>;
+export type ParticleNode = NodeBase & Readonly<{
+    kind: "particle";
+    occurs: Occurs;
+    term: Readonly<{
+        kind: "sequence" | "choice" | "all";
+        children: readonly NodeId[];
+    } | {
+        kind: "element";
+        declaration: Reference;
+    } | {
+        kind: "group";
+        reference: Reference;
+    } | {
+        kind: "any";
+        wildcard: Wildcard;
+    }>;
+}>;
+export type AttributeUseNode = NodeBase & Readonly<{
+    kind: "attributeUse";
+    declaration: Reference;
+    use: "optional" | "required" | "prohibited";
+    value?: ValueConstraint;
+}>;
+export type AttributeGroupUseNode = NodeBase & Readonly<{
+    kind: "attributeGroupUse";
+    reference: Reference;
+}>;
+export type AttributeWildcardNode = NodeBase & Readonly<{
+    kind: "attributeWildcard";
+    wildcard: Wildcard;
+}>;
+export type SimpleTypeNode = NodeBase & Readonly<{
+    kind: "simpleType";
+    variety: Readonly<{
+        kind: "restriction";
+        base: Reference;
+        facets: readonly Facet[];
+    } | {
+        kind: "list";
+        item: Reference;
+    } | {
+        kind: "union";
+        members: readonly Reference[];
+    }>;
+}>;
+export type ComplexTypeNode = NodeBase & Readonly<{
+    kind: "complexType";
+    mixed: boolean;
+    abstract: boolean;
+    content?: NodeId;
+    attributes: readonly NodeId[];
+    derivation?: Readonly<{
+        kind: "extension" | "restriction";
+        contentKind: "simple" | "complex";
+        base: Reference;
+        inlineType?: Reference;
+        facets: readonly Facet[];
+    }>;
+}>;
+export type GroupNode = NodeBase & Readonly<{
+    kind: "group";
+    content: NodeId;
+}>;
+export type AttributeGroupNode = NodeBase & Readonly<{
+    kind: "attributeGroup";
+    attributes: readonly NodeId[];
+}>;
+/** WSDL names/references and ordered binding syntax; transport interpretation remains downstream. */
+export type WsdlNode = NodeBase & Readonly<{
+    kind: "wsdl";
+    role: "message" | "portType" | "binding" | "service";
+    name: ExpandedName;
+    references: readonly Readonly<{
+        path: string;
+        attribute: string;
+        reference: Reference;
+    }>[];
+    syntax: SyntaxElement;
+}>;
+export type GraphNode = ElementNode | AttributeNode | ParticleNode | AttributeUseNode | AttributeGroupUseNode | AttributeWildcardNode | SimpleTypeNode | ComplexTypeNode | GroupNode | AttributeGroupNode | WsdlNode;
+export type GraphOrigin = Readonly<{
+    interpretation: string;
+    context: GraphContext;
+}>;
+export type CanonicalGraph = Readonly<{
+    model: typeof GRAPH_MODEL;
+    nodes: readonly GraphNode[];
+    globals: readonly NodeId[];
+    origins: Readonly<Record<NodeId, readonly GraphOrigin[]>>;
+    schemaAnnotations: readonly SyntaxElement[];
+    schemaRetained: readonly Readonly<{
+        context: GraphContext;
+        syntax: SyntaxElement;
+    }>[];
+    /** Includes/imports are provenance, never symbol identity or eager composition. */
+    loading: Readonly<{
+        limits: import("../loader/schemaResources.js").LoadingLimits;
+        edges: readonly import("../loader/schemaInput.js").ResolutionEdge[];
+    }>;
+}>;
+export declare class GraphError extends Error {
+    readonly category: "invalid-schema" | "resource-limit";
+    readonly source?: SyntaxSource | undefined;
+    constructor(category: "invalid-schema" | "resource-limit", message: string, source?: SyntaxSource | undefined);
+}
+export declare function globalId(role: SymbolRole, name: ExpandedName): NodeId;
+export declare function scopedId(owner: NodeId, path: string, role: string): NodeId;
+export declare function wsdlReferenceRoles(node: SyntaxElement): Record<string, SymbolRole>;
+export declare function deepFreeze<T>(value: T): T;
+export {};

package/dist/compiler/canonicalGraph.js

@@ -0,0 +1,37 @@
+/** Internal, language-neutral S04 contract. S05 resolves and composes these references. */
+import { createHash } from "node:crypto";
+import { WSDL_NAMESPACE } from "../loader/orderedSyntax.js";
+export const GRAPH_MODEL = "xsd10-faithful-v1";
+export const DEFAULT_GRAPH_NODES = 100_000;
+const builtinTypes = new Set("anyType anySimpleType string boolean decimal float double duration dateTime time date gYearMonth gYear gMonthDay gDay gMonth hexBinary base64Binary anyURI QName NOTATION normalizedString token language NMTOKEN NMTOKENS Name NCName ID IDREF IDREFS ENTITY ENTITIES integer nonPositiveInteger negativeInteger long int short byte nonNegativeInteger unsignedLong unsignedInt unsignedShort unsignedByte positiveInteger".split(" "));
+export const isBuiltinType = (local) => builtinTypes.has(local);
+export class GraphError extends Error {
+    category;
+    source;
+    constructor(category, message, source) {
+        super(message);
+        this.category = category;
+        this.source = source;
+        this.name = "GraphError";
+    }
+}
+export function globalId(role, name) {
+    return JSON.stringify(["global", role, name.namespace, name.local]);
+}
+export function scopedId(owner, path, role) {
+    return "scoped:" + createHash("sha256").update(JSON.stringify([owner, path, role])).digest("hex");
+}
+export function wsdlReferenceRoles(node) {
+    if (node.name.namespace !== WSDL_NAMESPACE)
+        return {};
+    return node.name.local === "part" ? { element: "element", type: "type" } : node.name.local === "binding" ? { type: "portType" }
+        : node.name.local === "port" ? { binding: "binding" } : ["input", "output", "fault"].includes(node.name.local) ? { message: "message" } : {};
+}
+export function deepFreeze(value) {
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}

package/dist/compiler/catalogErrors.d.ts

@@ -0,0 +1,17 @@
+export declare class CatalogError extends Error {
+    readonly category: "incompatible-artifact" | "invalid-schema" | "resource-limit";
+    readonly field?: string | undefined;
+    constructor(category: "incompatible-artifact" | "invalid-schema" | "resource-limit", message: string, field?: string | undefined);
+}
+export declare const DEFAULT_CATALOG_BYTES: number;
+export declare const DEFAULT_CATALOG_DEPTH = 1024;
+export type CatalogLimits = {
+    maxBytes?: number;
+    maxDepth?: number;
+    maxNodes?: number;
+};
+/** Property ordering is display ordering; array ordering always remains semantic. */
+export declare function canonicalJson(value: unknown): string;
+export declare function positiveLimit(value: number | undefined, fallback: number, name: string): number;
+/** Scan nesting before JSON.parse can allocate an arbitrarily deep input. */
+export declare function parseCatalogJson(text: string, limits?: CatalogLimits): unknown;