@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/re01TypeProperties.d.ts

@@ -0,0 +1,70 @@
+/** Explicit XSD type properties, separate from canonical XML source contributions. */
+import type { NodeId, Reference } from './canonicalGraph.js';
+import type { NamespaceConstraint, WildcardProcess } from './wildcardAlgebra.js';
+import type { SemanticBudget } from './semanticBudget.js';
+import type { SemanticTypeReference } from './semanticTypeReference.js';
+export declare const RE01_DERIVATION_DOMAIN: "RE01-derivation-B-v1";
+export type ComplexDerivationMethod = 'extension' | 'restriction';
+declare const originalParticleAuthority: unique symbol;
+/** Opaque selection of an actual source-mapped particle, never a validity receipt. */
+export type OriginalComplexParticleHandle = Readonly<{
+    owner: NodeId;
+    particle: NodeId;
+    [originalParticleAuthority]: true;
+}>;
+declare const originalUrWildcardAuthority: unique symbol;
+/** Unchanged actual-source native UR leaf, never a caller-supplied origin flag. */
+export type OriginalUrWildcardHandle = Readonly<{
+    owner: NodeId;
+    particle: NodeId;
+    [originalUrWildcardAuthority]: true;
+}>;
+export type RawComplexContent = Readonly<{
+    kind: 'empty';
+} | {
+    kind: 'simple';
+    type: SemanticTypeReference;
+} | {
+    kind: 'mixed' | 'element-only';
+    particle: NodeId;
+    original?: OriginalComplexParticleHandle;
+} | {
+    kind: 'opaque-builtin';
+    type: Reference;
+}>;
+/**
+ * This is supplied data, not a checked semantic receipt. In particular the
+ * actual-mapped label does not authenticate effective-property computation.
+ * The aggregate owner must compare with privately issued actual owner evidence.
+ */
+export type RawComplexTypeProperties = Readonly<{
+    type: NodeId;
+    /** Explicit semantic namespace for anonymous helpers; empty means absent.
+     * Omission supplies no namespace fact for a fresh scoped helper. */
+    targetNamespace?: string;
+    derivation: Readonly<{
+        base: SemanticTypeReference;
+        method: ComplexDerivationMethod;
+    }>;
+    abstract: boolean;
+    final: readonly ComplexDerivationMethod[];
+    block: readonly ComplexDerivationMethod[];
+    content: RawComplexContent;
+    /** Complete effective AU identities, including inherited uses; never a QName map. */
+    attributeUses: readonly NodeId[];
+    wildcard?: Readonly<{
+        namespace: NamespaceConstraint;
+        processContents: WildcardProcess;
+        sources: readonly NodeId[];
+    }>;
+    provenance: Readonly<{
+        kind: 'actual-mapped';
+        original: NodeId;
+    } | {
+        kind: 'hypothetical-abstract';
+        originals: readonly NodeId[];
+    }>;
+}>;
+/** Runtime data-shape boundary, shared by preparation and property consumers. */
+export declare function assertRawComplexTypeShape(value: unknown, budget: SemanticBudget): asserts value is RawComplexTypeProperties;
+export {};

package/dist/compiler/re01TypeProperties.js

@@ -0,0 +1,120 @@
+import { assertSemanticTypeReferenceShape } from './semanticTypeReference.js';
+export const RE01_DERIVATION_DOMAIN = 'RE01-derivation-B-v1';
+/** Runtime data-shape boundary, shared by preparation and property consumers. */
+export function assertRawComplexTypeShape(value, budget) {
+    const fail = () => { throw new TypeError('Invalid raw complex type properties'); };
+    const object = (v, fields) => {
+        budget.chargeWork(3);
+        if (!v || typeof v !== 'object' || Array.isArray(v))
+            return fail();
+        const prototype = Object.getPrototypeOf(v);
+        if (prototype !== Object.prototype && prototype !== null)
+            return fail();
+        for (const key of fields) {
+            budget.chargeWork(46 + key.length);
+            const field = Object.getOwnPropertyDescriptor(v, key);
+            if (field && !('value' in field))
+                return fail();
+        }
+        for (const key in v) {
+            budget.chargeWork(46 + key.length + fields.length);
+            const field = Object.getOwnPropertyDescriptor(v, key);
+            if (!field || !('value' in field) || !fields.includes(key))
+                return fail();
+        }
+        return v;
+    };
+    const id = (v) => { budget.chargeWork(); if (typeof v !== 'string' || !v)
+        fail(); };
+    const list = (v, item) => {
+        budget.chargeWork();
+        if (!Array.isArray(v))
+            return fail();
+        for (let index = 0; index < v.length; index++) {
+            budget.chargeWork(60);
+            const field = Object.getOwnPropertyDescriptor(v, index);
+            if (!field || !('value' in field))
+                return fail();
+            item(field.value);
+        }
+    };
+    const method = (v) => { budget.chargeWork(); if (v !== 'restriction' && v !== 'extension')
+        fail(); };
+    const reference = (v) => {
+        assertSemanticTypeReferenceShape(v, budget);
+        const kind = object(v, ['kind', 'owner', 'target', 'name', 'role', 'lexical']);
+        if (kind['kind'] === 'original-generated') {
+            id(kind['owner']);
+            return;
+        }
+        const r = object(v, ['kind', 'target', 'name', 'role', 'lexical']);
+        if (r['kind'] === 'local') {
+            id(r['target']);
+            return;
+        }
+        if (r['kind'] !== 'symbol' && r['kind'] !== 'builtin')
+            return fail();
+        const name = object(r['name'], ['namespace', 'local']);
+        if (typeof name['namespace'] !== 'string')
+            return fail();
+        id(name['local']);
+        if (r['kind'] === 'symbol' && r['role'] !== 'type')
+            return fail();
+        if (r['target'] !== undefined)
+            id(r['target']);
+    };
+    const r = object(value, ['type', 'targetNamespace', 'derivation', 'abstract', 'final', 'block', 'content', 'attributeUses', 'wildcard', 'provenance']);
+    id(r['type']);
+    if (r['targetNamespace'] !== undefined && typeof r['targetNamespace'] !== 'string')
+        return fail();
+    const d = object(r['derivation'], ['base', 'method']);
+    method(d['method']);
+    reference(d['base']);
+    if (typeof r['abstract'] !== 'boolean')
+        return fail();
+    list(r['final'], method);
+    list(r['block'], method);
+    list(r['attributeUses'], id);
+    const content = object(r['content'], ['kind', 'type', 'particle', 'original']);
+    if (content['kind'] === 'simple' || content['kind'] === 'opaque-builtin') {
+        if ('particle' in content || 'original' in content)
+            return fail();
+        reference(content['type']);
+    }
+    else if (content['kind'] === 'mixed' || content['kind'] === 'element-only') {
+        if ('type' in content)
+            return fail();
+        id(content['particle']);
+        if (content['original'] !== undefined) {
+            const original = object(content['original'], ['owner', 'particle']);
+            id(original['owner']);
+            id(original['particle']);
+        }
+    }
+    else if (content['kind'] !== 'empty' || 'type' in content || 'particle' in content || 'original' in content)
+        return fail();
+    if (r['wildcard'] !== undefined) {
+        const w = object(r['wildcard'], ['namespace', 'processContents', 'sources']);
+        if (w['processContents'] !== 'strict' && w['processContents'] !== 'lax' && w['processContents'] !== 'skip')
+            return fail();
+        const n = object(w['namespace'], ['kind', 'namespaces']);
+        if (n['kind'] !== 'set' && n['kind'] !== 'not')
+            return fail();
+        list(n['namespaces'], ns => { budget.chargeWork(); if (typeof ns !== 'string')
+            fail(); });
+        list(w['sources'], id);
+    }
+    const provenance = object(r['provenance'], ['kind', 'original', 'originals']);
+    if (provenance['kind'] === 'actual-mapped') {
+        if ('originals' in provenance)
+            return fail();
+        id(provenance['original']);
+    }
+    else if (provenance['kind'] === 'hypothetical-abstract') {
+        if ('original' in provenance)
+            return fail();
+        list(provenance['originals'], id);
+    }
+    else
+        fail();
+}

package/dist/compiler/re01TypePropertyValidation.d.ts

@@ -0,0 +1,22 @@
+/** Structural checks of explicit abstract properties, separate from source mapping. */
+import type { NodeId } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import { RE01_DERIVATION_DOMAIN } from './re01TypeProperties.js';
+import type { RawComplexTypeProperties } from './re01TypeProperties.js';
+import type { CorrespondenceReceipt } from './re01CandidateCorrespondence.js';
+export type RawTypeValidation = Readonly<{
+    kind: 'checked-structure';
+    contract: typeof RE01_DERIVATION_DOMAIN;
+    component: NodeId;
+    context: string;
+    properties: RawComplexTypeProperties;
+    mappingAuthority: 'none';
+    remaining: readonly ['effective-property-mapping', 'complete-type-validity', 'endpoint-correspondence', 'all-original-property-correspondence'];
+}> | Readonly<{
+    kind: 'invalid-input' | 'unresolved';
+    rule: string;
+    component: NodeId;
+}> | ResourceLimitFailure;
+/** The context has already copied data and rejected accessors. No caller labels authenticate actual mapping. */
+export declare function validateRawComplexTypeProperties(context: SemanticContext, typeId: NodeId, correspondence?: CorrespondenceReceipt): RawTypeValidation;

package/dist/compiler/re01TypePropertyValidation.js

@@ -0,0 +1,161 @@
+import { resolveSemanticType, semanticTypeKey } from './schemaTypeIdentity.js';
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { assertSemanticContext, SemanticContextAccessError } from './semanticContext.js';
+import { RE01_DERIVATION_DOMAIN } from './re01TypeProperties.js';
+import { assertCandidateCorrespondence } from './re01CandidateCorrespondence.js';
+import { deriveRawComplexContent, particleContentNode } from './complexTypeContent.js';
+class InvalidRawType extends Error {
+    rule;
+    unresolved;
+    constructor(rule, unresolved = false) {
+        super(rule);
+        this.rule = rule;
+        this.unresolved = unresolved;
+    }
+}
+/** The context has already copied data and rejected accessors. No caller labels authenticate actual mapping. */
+export function validateRawComplexTypeProperties(context, typeId, correspondence) {
+    assertSemanticContext(context);
+    if (correspondence)
+        assertCandidateCorrespondence(context, correspondence);
+    const b = context.budget;
+    return b.guard(() => {
+        try {
+            b.chargeWork(3 + typeId.length);
+            const fail = (rule, unresolved = false) => { throw new InvalidRawType(rule, unresolved); };
+            const node = (id, kind) => {
+                b.chargeWork(3);
+                const result = context.lookup(id);
+                if (result.kind !== 'found')
+                    return fail(`raw-type-${result.kind}`, true);
+                if (kind !== undefined && result.node.kind !== kind)
+                    return fail('raw-type-reference-role');
+                return result.node;
+            };
+            const reference = (value, simple = false) => {
+                b.chargeWork(3);
+                const result = resolveSemanticType(context, value);
+                if (result.kind === 'builtin') {
+                    if (simple && result.name.local === 'anyType')
+                        return fail('raw-type-content-role');
+                    return semanticTypeKey(context, result.identity);
+                }
+                if (result.kind === 'original-generated')
+                    return semanticTypeKey(context, result.identity);
+                if (result.kind === 'wrong-role')
+                    return fail('raw-type-reference-role');
+                if (result.kind !== 'component')
+                    return fail(`raw-type-${result.kind}`, true);
+                if (simple && result.node.kind !== 'simpleType')
+                    return fail('raw-type-content-role');
+                return semanticTypeKey(context, result.identity);
+            };
+            const methods = (value) => {
+                b.chargeWork(2);
+                const seen = new Set();
+                for (const method of value) {
+                    b.chargeWork(5);
+                    if (seen.has(method))
+                        return fail('raw-type-methods');
+                    seen.add(method);
+                }
+            };
+            const owner = node(typeId, 'complexType');
+            if (owner.kind !== 'complexType')
+                return fail('raw-type-owner');
+            const supplied = context.rawTypeProperties(typeId);
+            if (!supplied)
+                return fail('missing-raw-complex-type-properties', true);
+            // assertRawComplexTypeShape is the single shape gate in the authenticated
+            // context factory. These checks add selected-context consistency only.
+            const raw = supplied;
+            if (raw.type !== typeId || raw.abstract !== owner.abstract)
+                return fail('raw-type-owner-properties');
+            if (raw.targetNamespace !== undefined && owner.identity.kind === 'global' &&
+                b.compareText(raw.targetNamespace, owner.identity.name.namespace) !== 0)
+                return fail('raw-type-target-namespace');
+            if (raw.targetNamespace === undefined && owner.identity.kind === 'scoped' && !context.sourceNode(owner.id))
+                return fail('missing-raw-type-target-namespace', true);
+            methods(raw.final);
+            methods(raw.block);
+            const derivation = raw.derivation;
+            if (derivation.method !== (owner.derivation?.kind ?? 'restriction'))
+                return fail('raw-type-derivation');
+            const base = reference(derivation.base);
+            const ur = { kind: 'builtin', name: { namespace: XSD_NAMESPACE, local: 'anyType' } };
+            // Canonical Reference cannot encode the private scalar slot. That explicit
+            // semantic base replaces only the unrepresentable source placeholder;
+            // ordinary bases retain the existing representation-coherence check.
+            if (derivation.base.kind !== 'original-generated') {
+                const canonicalBase = owner.derivation ? reference(owner.derivation.base) : reference(ur);
+                if (b.compareText(base, canonicalBase) !== 0)
+                    return fail('raw-type-derivation');
+            }
+            const content = raw.content;
+            switch (content.kind) {
+                case 'empty': break;
+                case 'simple':
+                    reference(content.type, true);
+                    break;
+                case 'mixed':
+                case 'element-only':
+                    if (content.original) {
+                        const mapped = deriveRawComplexContent(context, typeId);
+                        if (mapped.kind === 'resource-limit')
+                            return mapped;
+                        if (mapped.kind !== 'checked' || particleContentNode(context, mapped.view, content.particle)?.kind !== 'particle')
+                            return fail('raw-type-original-particle', true);
+                    }
+                    else
+                        node(content.particle, 'particle');
+                    break;
+                case 'opaque-builtin':
+                    if (b.compareText(reference(content.type), reference(ur)) !== 0)
+                        return fail('raw-type-content');
+                    break;
+            }
+            b.chargeWork();
+            const uses = new Set();
+            for (const id of raw.attributeUses) {
+                const use = node(id, 'attributeUse');
+                b.chargeWork(4 + use.id.length);
+                if (use.kind !== 'attributeUse' || use.use === 'prohibited' || uses.has(use.id))
+                    return fail('raw-type-attribute-uses');
+                uses.add(use.id);
+            }
+            for (const id of raw.wildcard?.sources ?? []) {
+                b.chargeWork();
+                node(id, 'attributeWildcard');
+            }
+            const provenance = raw.provenance;
+            if (provenance.kind === 'actual-mapped') {
+                b.chargeWork(1 + (correspondence?.originalProperties.length ?? 0));
+                if (!correspondence?.originalProperties.includes(typeId) || provenance.original !== typeId)
+                    return fail('unauthenticated-actual-type-mapping', true);
+            }
+            for (const original of provenance.kind === 'hypothetical-abstract' ? provenance.originals : []) {
+                b.chargeWork(2);
+                if (!context.sourceNode(original))
+                    return fail('raw-type-provenance');
+            }
+            b.chargeWork(160 + context.contextId.length + typeId.length);
+            // The returned raw value was frozen by the context. It remains supplied
+            // data: neither this label nor these references prove effective mapping.
+            return Object.freeze({ kind: 'checked-structure', contract: RE01_DERIVATION_DOMAIN,
+                component: typeId, context: context.contextId, properties: supplied, mappingAuthority: 'none',
+                remaining: Object.freeze(['effective-property-mapping', 'complete-type-validity', 'endpoint-correspondence',
+                    'all-original-property-correspondence']) });
+        }
+        catch (error) {
+            if (error instanceof InvalidRawType) {
+                b.chargeWork(5);
+                return Object.freeze({ kind: error.unresolved ? 'unresolved' : 'invalid-input', rule: error.rule, component: typeId });
+            }
+            if (error instanceof SemanticContextAccessError) {
+                b.chargeWork(5);
+                return Object.freeze({ kind: error.code === 'reference' ? 'invalid-input' : 'unresolved', rule: `raw-type-${error.code}`, component: typeId });
+            }
+            throw error;
+        }
+    });
+}

package/dist/compiler/resolveCanonicalGraph.d.ts

@@ -0,0 +1,41 @@
+import type { CanonicalGraph, GraphNode, NodeId, Reference } from "./canonicalGraph.js";
+import type { SyntaxSource } from "../loader/orderedSyntax.js";
+import type { StandardSchemaLibrary, StandardSchemaElementDeclaration } from './standardSchemaComponents.js';
+export declare class SemanticError extends Error {
+    readonly category: "invalid-schema" | "unsupported-capability" | "incompatible-artifact" | "resource-limit";
+    readonly component?: NodeId | undefined;
+    readonly source?: SyntaxSource | undefined;
+    readonly related: readonly SyntaxSource[];
+    constructor(category: "invalid-schema" | "unsupported-capability" | "incompatible-artifact" | "resource-limit", message: string, component?: NodeId | undefined, source?: SyntaxSource | undefined, related?: readonly SyntaxSource[]);
+}
+export type SemanticLimits = {
+    maxNodes?: number;
+    maxSteps?: number;
+    requestBudget?: import("./semanticBudget.js").SemanticBudget;
+    standardLibraries?: readonly StandardSchemaLibrary[];
+};
+export declare function semanticBudget(limits?: SemanticLimits): {
+    maxNodes: number;
+    readonly steps: number;
+    step(node?: GraphNode): void;
+};
+/** Count structural data before retaining another input or serializing a copy. */
+export declare function countSemanticData(value: unknown, budget: ReturnType<typeof semanticBudget>, node?: GraphNode): void;
+export type ResolvedLink = Readonly<{
+    owner: NodeId;
+    path: string;
+    reference: Reference;
+    target?: NodeId;
+}>;
+export type ResolvedGraph = Readonly<{
+    graph: CanonicalGraph;
+    links: readonly ResolvedLink[];
+    metrics: Readonly<{
+        steps: number;
+    }>;
+}>;
+/** Native acquired dependencies only; copied graph reports cannot recreate this association. */
+export declare function standardSchemaLibrariesForResolved(resolved: ResolvedGraph): readonly StandardSchemaLibrary[] | undefined;
+/** Resolve against a node index, never against generated names or an asserted stored target. */
+export declare function referenceTarget(reference: Reference, nodes: ReadonlyMap<NodeId, GraphNode>, owner: GraphNode, standards?: ReadonlyMap<NodeId, StandardSchemaElementDeclaration>): NodeId | undefined;
+export declare function resolveCanonicalGraph(graph: CanonicalGraph, limits?: SemanticLimits): ResolvedGraph;

package/dist/compiler/resolveCanonicalGraph.js

@@ -0,0 +1,240 @@
+/** Pure S05 reference assessment. Definitions and use-site occurrences remain canonical. */
+import { deepFreeze, DEFAULT_GRAPH_NODES, globalId, isBuiltinType } from "./canonicalGraph.js";
+import { positiveLimit } from "./catalogErrors.js";
+import { referenceSlots, containedNodes } from "./graphTraversal.js";
+import { syntaxAttribute, XSD_NAMESPACE } from "../loader/orderedSyntax.js";
+import { normalizeWhitespace } from '../util/xmlWhitespace.js';
+import { standardSchemaElement, inspectStandardSchemaElement } from './standardSchemaComponents.js';
+export class SemanticError extends Error {
+    category;
+    component;
+    source;
+    related;
+    constructor(category, message, component, source, related = []) {
+        super(message);
+        this.category = category;
+        this.component = component;
+        this.source = source;
+        this.related = related;
+        this.name = "SemanticError";
+    }
+}
+/** Internal missing-symbol detail; source resolution must distinguish absent import resources from disproved declarations. */
+class MissingReferenceError extends SemanticError {
+    constructor(reference, owner, id) {
+        super('invalid-schema', `Missing reference target ${id}`, owner.id, reference.kind === 'symbol' ? reference.lexical.context.source : owner.context.source);
+    }
+}
+export function semanticBudget(limits = {}) {
+    const maxNodes = positiveLimit(limits.maxNodes, DEFAULT_GRAPH_NODES, "maxNodes");
+    const maxSteps = positiveLimit(limits.maxSteps, 1_000_000, "maxSteps");
+    let steps = 0;
+    return { maxNodes, get steps() { return steps; }, step(node) {
+            limits.requestBudget?.chargeWork(64);
+            if (++steps > maxSteps)
+                throw new SemanticError("resource-limit", `Semantic traversal exceeds ${maxSteps} steps`, node?.id, node?.context.source);
+        } };
+}
+/** Count structural data before retaining another input or serializing a copy. */
+export function countSemanticData(value, budget, node) {
+    const stack = [value];
+    while (stack.length) {
+        const item = stack.pop();
+        budget.step(node);
+        if (typeof item === "string")
+            for (let i = 0; i < item.length; i++)
+                budget.step(node);
+        else if (item && typeof item === "object")
+            for (const key in item) {
+                if (!Object.hasOwn(item, key))
+                    continue;
+                budget.step(node);
+                for (let i = 0; i < key.length; i++)
+                    budget.step(node);
+                stack.push(item[key]);
+            }
+    }
+}
+const resolvedStandards = new WeakMap();
+/** Native acquired dependencies only; copied graph reports cannot recreate this association. */
+export function standardSchemaLibrariesForResolved(resolved) {
+    return resolvedStandards.get(resolved);
+}
+/** Resolve against a node index, never against generated names or an asserted stored target. */
+export function referenceTarget(reference, nodes, owner, standards) {
+    if (reference.kind === "builtin") {
+        if (reference.name.namespace !== XSD_NAMESPACE || !isBuiltinType(reference.name.local))
+            throw new SemanticError("invalid-schema", "Unknown builtin type", owner.id, owner.context.source);
+        return undefined;
+    }
+    const id = reference.kind === "symbol" ? globalId(reference.role, reference.name) : reference.target;
+    const target = nodes.get(id);
+    if (!target) {
+        const supplied = standards?.get(id);
+        if (!supplied)
+            throw new MissingReferenceError(reference, owner, id);
+        inspectStandardSchemaElement(supplied);
+        if (reference.kind !== 'symbol' || reference.role !== 'element' || supplied.id !== id
+            || reference.target !== undefined && reference.target !== id)
+            throw new SemanticError('invalid-schema', 'Standard declaration reference role/identity mismatch', owner.id, owner.context.source);
+        return id;
+    }
+    if (reference.kind === "symbol" && (target.identity.kind !== "global" || target.identity.role !== reference.role || (reference.target !== undefined && reference.target !== id))) {
+        throw new SemanticError("invalid-schema", `Reference role/identity mismatch ${id}`, owner.id, reference.lexical.context.source);
+    }
+    return id;
+}
+function interpretation(key) {
+    if (!key.startsWith("["))
+        return { namespace: "", document: key };
+    const tuple = JSON.parse(key);
+    return { namespace: tuple[3], document: tuple[1] };
+}
+export function resolveCanonicalGraph(graph, limits = {}) {
+    const budget = semanticBudget(limits);
+    if (graph.nodes.length > budget.maxNodes)
+        throw new SemanticError("resource-limit", `Resolution exceeds ${budget.maxNodes} graph nodes`);
+    // Separate precharged graph traversal covers initial index and retained-import table preparation.
+    limits.requestBudget?.freeze(graph);
+    const nodes = new Map(graph.nodes.map(n => [n.id, n]));
+    if (nodes.size !== graph.nodes.length)
+        throw new SemanticError("invalid-schema", "Duplicate graph identities");
+    const standards = new Map(), selectedLibraries = [];
+    for (const library of limits.standardLibraries ?? []) {
+        budget.step();
+        const declaration = standardSchemaElement(library, { namespace: XSD_NAMESPACE, local: 'schema' });
+        if (!declaration)
+            throw new SemanticError('unsupported-capability', 'Standard library supplies no implemented schema element');
+        if (standards.has(declaration.id))
+            throw new SemanticError('unsupported-capability', 'Duplicate standard library selection');
+        if (nodes.has(declaration.id))
+            throw new SemanticError('unsupported-capability', 'Acquired standard declaration conflicts with explicit schema source; select one source authority');
+        standards.set(declaration.id, declaration);
+        selectedLibraries.push(library);
+    }
+    // Imports authorize foreign namespaces in the declaring interpretation only.
+    // Including/importing documents do not lend their import permissions to a reference.
+    const imports = new Map(), unknownImports = new Set();
+    const unlocatedImports = new Map();
+    const sourceKey = (source) => JSON.stringify([source.uri, source.digest, source.path]);
+    const importSyntax = new Map(graph.schemaRetained.filter(r => r.syntax.name.namespace === XSD_NAMESPACE && r.syntax.name.local === "import")
+        .map(r => [sourceKey(r.syntax.source), r.syntax]));
+    for (const edge of graph.loading.edges) {
+        budget.step();
+        if (edge.kind !== "import")
+            continue;
+        const syntax = importSyntax.get(sourceKey(edge.source));
+        const ns = syntax ? normalizeWhitespace(syntaxAttribute(syntax, "namespace") ?? "", 'collapse') : edge.to ? interpretation(edge.to).namespace : undefined;
+        if (ns === undefined) {
+            unknownImports.add(edge.from);
+            continue;
+        }
+        if (ns === interpretation(edge.from).namespace)
+            throw new SemanticError("invalid-schema", "Import must authorize a different namespace", undefined, edge.source);
+        const values = imports.get(edge.from) ?? new Set();
+        values.add(ns);
+        imports.set(edge.from, values);
+        if (!edge.to && syntax && syntaxAttribute(syntax, 'schemaLocation') === undefined) {
+            const pending = unlocatedImports.get(edge.from) ?? new Set();
+            pending.add(ns);
+            unlocatedImports.set(edge.from, pending);
+        }
+    }
+    const links = [];
+    let unresolvedImport;
+    for (const node of graph.nodes) {
+        budget.step(node);
+        for (const slot of referenceSlots(node)) {
+            budget.step(node);
+            const ref = slot.reference;
+            let target;
+            let unavailable;
+            try {
+                target = referenceTarget(ref, nodes, node, standards);
+            }
+            catch (error) {
+                if (error instanceof MissingReferenceError && ref.kind === 'symbol' && node.kind !== 'wsdl') {
+                    for (const origin of graph.origins[node.id] ?? []) {
+                        budget.step(node);
+                        if (ref.name.namespace !== origin.context.effectiveNamespace && unlocatedImports.get(origin.interpretation)?.has(ref.name.namespace)) {
+                            unavailable = new SemanticError('unsupported-capability', `Missing declaration in namespace ${ref.name.namespace}; supply the locationless import dependency explicitly`, node.id, ref.lexical.context.source);
+                            break;
+                        }
+                    }
+                }
+                if (!unavailable)
+                    throw error;
+            }
+            // @why P1-D01: missing dependency evidence must not mask independent actual reference failures.
+            if (unavailable) {
+                unresolvedImport ??= unavailable;
+                continue;
+            }
+            if (ref.kind === "symbol" && node.kind !== "wsdl") {
+                for (const origin of graph.origins[node.id] ?? []) {
+                    budget.step(node);
+                    if (ref.name.namespace === origin.context.effectiveNamespace)
+                        continue;
+                    if (!imports.get(origin.interpretation)?.has(ref.name.namespace)) {
+                        if (unknownImports.has(origin.interpretation))
+                            throw new SemanticError("incompatible-artifact", "Catalog lacks namespace evidence for an unlocated import; regenerate from original source", node.id, ref.lexical.context.source);
+                        throw new SemanticError("invalid-schema", `Reference namespace ${ref.name.namespace} is not imported`, node.id, ref.lexical.context.source);
+                    }
+                }
+            }
+            links.push({ owner: node.id, path: slot.path, reference: ref, ...(target ? { target } : {}) });
+        }
+    }
+    if (unresolvedImport)
+        throw unresolvedImport;
+    // Only expansion/base edges enter this DAG. Element -> type and particle -> element
+    // are deliberately excluded: crossing an element admits complete recursive values.
+    const forbidden = (n) => {
+        limits.requestBudget?.freeze(n);
+        const result = [...containedNodes(n)];
+        for (const slot of referenceSlots(n)) {
+            const expansion = n.kind === "simpleType" || n.kind === "complexType" || n.kind === "attributeGroupUse" ||
+                (n.kind === "particle" && n.term.kind === "group") || (n.kind === "element" && slot.path === "substitutionGroup");
+            if (expansion) {
+                const target = referenceTarget(slot.reference, nodes, n, standards);
+                if (target && standards.has(target))
+                    throw new SemanticError('unsupported-capability', 'Substitution affiliation to an acquired standard element is not implemented', n.id, n.context.source);
+                if (target)
+                    result.push(target);
+            }
+        }
+        return result;
+    };
+    const done = new Set(), active = new Set();
+    for (const root of graph.nodes) {
+        if (done.has(root.id))
+            continue;
+        const stack = [{ node: root, edges: forbidden(root), index: 0 }];
+        active.add(root.id);
+        while (stack.length) {
+            budget.step(stack[stack.length - 1].node);
+            const frame = stack[stack.length - 1];
+            if (frame.index === frame.edges.length) {
+                active.delete(frame.node.id);
+                done.add(frame.node.id);
+                stack.pop();
+                continue;
+            }
+            const id = frame.edges[frame.index++], child = nodes.get(id);
+            if (!child)
+                throw new SemanticError("invalid-schema", `Missing structural target ${id}`, frame.node.id, frame.node.context.source);
+            if (active.has(id)) {
+                const cycle = stack.slice(stack.findIndex(f => f.node.id === id));
+                throw new SemanticError("invalid-schema", `Forbidden component cycle: ${cycle.map(f => f.node.id).join(" -> ")} -> ${id}`, frame.node.id, frame.node.context.source, cycle.map(f => f.node.context.source));
+            }
+            if (!done.has(id)) {
+                active.add(id);
+                stack.push({ node: child, edges: forbidden(child), index: 0 });
+            }
+        }
+    }
+    const result = { graph, links, metrics: { steps: budget.steps } };
+    const frozen = limits.requestBudget ? limits.requestBudget.freeze(result) : deepFreeze(result);
+    resolvedStandards.set(frozen, Object.freeze(selectedLibraries));
+    return frozen;
+}