@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/client/generateDirectClient.js

@@ -0,0 +1,136 @@
+import { directLimit } from '../compiler/directExecutionPolicy.js';
+import { DIRECT_CLIENT_RUNTIME_VERSION, DIRECT_CLIENT_RUNTIME_REPAIR } from './directClientVersion.js';
+/** Internal native-plan generator. Deliberately absent from index.ts and the CLI. */
+import { checkSemanticBudget } from '../compiler/semanticBudget.js';
+import { writeFileSync } from 'node:fs';
+import { inspectDirectOperation } from '../compiler/directOperation.js';
+import { inspectDirectValueMapping } from '../compiler/directValues.js';
+import { checkDirectSourceCompatibility, createDirectSourceCapsule } from '../compiler/directSourceCapsule.js';
+import { composeGeneratedSource, resolvePreamble } from '../generation/preamble.js';
+const MAX_SOURCE_BYTES = 512 * 1024;
+const generatedArtifacts = new WeakMap();
+/** Roles are separate declarations, so equal local names never merge namespace identities. */
+export function generateDirectClient(expected, signal) {
+    const { budget } = inspectDirectOperation(expected.contract).context;
+    const failure = (kind, rule) => ({ kind, rule,
+        repair: 'Regenerate matched internal direct artifacts from an explicitly authorized source.', usage: Object.freeze({ ...budget.usage() }) });
+    try {
+        const compatible = checkDirectSourceCompatibility(expected, expected.contract, expected.selection, signal);
+        if (compatible.kind !== 'compatible-direct')
+            return compatible;
+        const capsule = createDirectSourceCapsule(expected.contract, expected.selection, signal);
+        if (capsule.kind !== 'direct-capsule')
+            return capsule;
+        // Bound every variable emission before building strings. Six bytes per UTF-16
+        // unit covers JSON escapes; fixed per-slot/role costs cover TypeScript syntax.
+        let bound = 16_384 + Math.ceil(capsule.bytes.byteLength / 3) * 4;
+        for (const mapping of expected.mappings) {
+            inspectDirectValueMapping(mapping, expected.contract);
+            if (mapping.direction.kind === 'fault')
+                bound += mapping.direction.name.length * 6 + 512;
+            for (const slot of mapping.slots)
+                bound += 256 + slot.element.name.local.length * 6;
+        }
+        const selector = expected.contract.selector;
+        bound += 6 * (selector.operation.length * 2 + selector.portType.namespace.length + selector.portType.local.length
+            + selector.binding.namespace.length + selector.binding.local.length + expected.selection.service.namespace.length
+            + expected.selection.service.local.length + expected.selection.port.length);
+        if (bound > directLimit(budget, MAX_SOURCE_BYTES))
+            return failure('resource-limit', 'generated-source-byte-limit');
+        const literal = (text) => JSON.stringify(text).replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+        const primitive = (name) => {
+            if (name === 'string')
+                return 'string';
+            if (name === 'boolean')
+                return 'boolean';
+            if (name === 'int')
+                return 'number';
+            throw new TypeError('Unsupported native scalar plan');
+        };
+        const shape = (supplied) => {
+            const mapping = inspectDirectValueMapping(supplied, expected.contract);
+            if (mapping.rootBuiltin)
+                return primitive(mapping.rootBuiltin.local);
+            if (!mapping.slots.length)
+                return 'Readonly<Record<string, never>>';
+            return '{\n' + mapping.slots.map(slot => {
+                if (signal?.aborted)
+                    throw new Error('cancelled');
+                const item = primitive(slot.builtin.local), { min, max } = slot.particle.occurs;
+                const type = max === 'unbounded' ? min === '1' ? `readonly [${item}, ...${item}[]]` : `readonly ${item}[]` : item;
+                return `  readonly ${literal(slot.element.name.local)}${max === '1' && min === '0' ? '?' : ''}: ${type};`;
+            }).join('\n') + '\n}';
+        };
+        const mappings = expected.mappings;
+        const input = mappings.find(m => m.direction.kind === 'input');
+        const output = mappings.find(m => m.direction.kind === 'output');
+        const faults = mappings.filter(m => m.direction.kind === 'fault');
+        const lines = [
+            '// Checked direct client; inject checkedDirectRuntimeV1 from the package root.',
+            '// Generation remains internal; this unreleased binding supports only the documented direct grammar.',
+            '// Static number types require native int32 validation; native checks enforce exact shapes.',
+            `export type Request = ${shape(input)};`,
+            `export type Response = ${shape(output)};`,
+            ...faults.map((m, i) => `export type Fault_${i} = ${shape(m)};`),
+            'export interface Usage { readonly nodes: number; readonly work: number }',
+            'export interface Name { readonly namespace: string; readonly local: string }',
+            'export interface Options {',
+            '  readonly localSource: string; readonly fileRoots: readonly string[]; readonly capsule: Uint8Array;',
+            '  readonly soap: { readonly service: Name; readonly port: string; readonly endpoint: string;',
+            '    readonly allowEndpoint: (endpoint: URL) => boolean; readonly signal?: AbortSignal;',
+            '    readonly timeoutMs?: number; readonly capabilities?: readonly string[];',
+            '    readonly limits?: { readonly maxBytes?: number; readonly maxDepth?: number; readonly maxNodes?: number; readonly maxText?: number } };',
+            '}',
+            'export interface Failure {',
+            '  readonly kind: "incompatible-artifact" | "unsupported" | "missing-authority" | "resource-limit" | "cancelled" | "inconclusive" | "invalid-schema" | "scalar-invalid" | "value-invalid" | "xml-invalid" | "mismatch" | "transport" | "protocol";',
+            '  readonly rule: string; readonly repair?: string; readonly usage: Usage;',
+            '}',
+            'export interface NativeSuccess { readonly kind: "soap-response" | "soap-fault"; readonly value: unknown;',
+            '  readonly admitted: false; readonly status: number; readonly usage: Usage; readonly responseBytes: Uint8Array;',
+            '  readonly fault?: { readonly name: string; readonly code: Name; readonly string: string; readonly actor?: string }; }',
+            `export interface Runtime { readonly version: ${literal(DIRECT_CLIENT_RUNTIME_VERSION)}; execute(expectedBase64: string, input: unknown, options: Options, version: ${literal(DIRECT_CLIENT_RUNTIME_VERSION)}): Promise<Failure | NativeSuccess> }`,
+            'type Common = { readonly admitted: false; readonly status: number; readonly usage: Usage; readonly responseBytes: Uint8Array };',
+            'export type DeclaredFault = ' + (faults.length ? faults.map((m, i) => {
+                if (m.direction.kind !== 'fault')
+                    throw new TypeError('fault direction');
+                return `(Common & { readonly kind: "soap-fault"; readonly value: Fault_${i}; readonly fault: { readonly name: ${literal(m.direction.name)}; readonly code: Name; readonly string: string; readonly actor?: string } })`;
+            }).join(' | ') : 'never') + ';',
+            'export type Result = Failure | (Common & { readonly kind: "soap-response"; readonly value: Response }) | DeclaredFault;',
+            `const capsule = ${literal(Buffer.from(capsule.bytes).toString('base64'))};`,
+            `export const selection = ${literal(JSON.stringify({ selector: expected.contract.selector, ...expected.selection }))};`,
+            'export function createClient(runtime: Runtime) {',
+            '  return Object.freeze({',
+            `    [${literal(expected.contract.selector.operation)}]: async (input: Request, options: Options): Promise<Result> => {`,
+            `      if (runtime.version !== ${literal(DIRECT_CLIENT_RUNTIME_VERSION)}) return {kind: "incompatible-artifact", rule: "generated-runtime-version", repair: ${literal(DIRECT_CLIENT_RUNTIME_REPAIR)}, usage: {nodes: 0, work: 0}};`,
+            '      // The installed native binding pins the literal capsule before issuing fresh authority.',
+            `      return await runtime.execute(capsule, input, options, ${literal(DIRECT_CLIENT_RUNTIME_VERSION)}) as Result;`,
+            '    },',
+            '  });',
+            '}',
+            '',
+        ];
+        const source = composeGeneratedSource(lines.join('\n'), resolvePreamble('direct-client'));
+        if (Buffer.byteLength(source) > directLimit(budget, MAX_SOURCE_BYTES))
+            return failure('resource-limit', 'generated-source-byte-limit');
+        if (signal?.aborted)
+            return failure('cancelled', 'cooperative-cancellation');
+        const result = Object.freeze({ kind: 'generated-direct-client', source, capsule: capsule.bytes, admitted: false, usage: Object.freeze({ ...budget.usage() }) });
+        generatedArtifacts.set(result, budget);
+        return result;
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return failure('resource-limit', 'request-budget');
+        if (signal?.aborted)
+            return failure('cancelled', 'cooperative-cancellation');
+        throw error;
+    }
+}
+/** Only authentic bounded artifacts may be written; prior semantic failure remains terminal. */
+export function writeDirectClient(file, generated) {
+    const budget = generatedArtifacts.get(generated);
+    if (!budget)
+        throw new TypeError('Authentic generated artifact required');
+    checkSemanticBudget(budget);
+    writeFileSync(file, generated.source, 'utf8');
+}

package/dist/compiler/buildCanonicalGraph.d.ts

@@ -0,0 +1,7 @@
+import type { SchemaInput } from "../loader/schemaInput.js";
+import type { CanonicalGraph } from "./canonicalGraph.js";
+export declare function buildCanonicalGraph(input: SchemaInput, options?: {
+    maxNodes?: number;
+    requestBudget?: import("./semanticBudget.js").SemanticBudget;
+}): CanonicalGraph;
+//# sourceMappingURL=buildCanonicalGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildCanonicalGraph.d.ts","sourceRoot":"","sources":["../../src/compiler/buildCanonicalGraph.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,WAAW,EAAuB,MAAM,0BAA0B,CAAC;AAEhF,OAAO,KAAK,EAAC,cAAc,EAAwI,MAAM,qBAAqB,CAAC;AAS/L,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,GAAE;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,cAAc,CAAA;CAAM,GAAG,cAAc,CAmSvK"}

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);
+}