@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/compiler/canonicalGraph.d.ts

@@ -0,0 +1,198 @@
+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 {};
+//# sourceMappingURL=canonicalGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalGraph.d.ts","sourceRoot":"","sources":["../../src/compiler/canonicalGraph.ts"],"names":[],"mappings":"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"}

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,18 @@
+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;
+//# sourceMappingURL=catalogErrors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catalogErrors.d.ts","sourceRoot":"","sources":["../../src/compiler/catalogErrors.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAa,SAAQ,KAAK;IACzB,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,GAAG,gBAAgB,GAAG,gBAAgB;IAAmB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM;gBAAjH,QAAQ,EAAE,uBAAuB,GAAG,gBAAgB,GAAG,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAW,KAAK,CAAC,EAAE,MAAM,YAAA;CAGvI;AACD,eAAO,MAAM,qBAAqB,QAAmB,CAAC;AACtD,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAC1C,MAAM,MAAM,aAAa,GAAG;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AAEtF,qFAAqF;AACrF,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAOpD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAI/F;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,aAAkB,GAAG,OAAO,CA8BlF"}

package/dist/compiler/catalogErrors.js

@@ -0,0 +1,86 @@
+export class CatalogError extends Error {
+    category;
+    field;
+    constructor(category, message, field) {
+        super(message);
+        this.category = category;
+        this.field = field;
+        this.name = "CatalogError";
+    }
+}
+export const DEFAULT_CATALOG_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_CATALOG_DEPTH = 1024;
+/** Property ordering is display ordering; array ordering always remains semantic. */
+export function canonicalJson(value) {
+    const order = (v) => {
+        if (Array.isArray(v))
+            return v.map(order);
+        if (v && typeof v === "object")
+            return Object.fromEntries(Object.keys(v).sort().filter(k => v[k] !== undefined).map(k => [k, order(v[k])]));
+        return v;
+    };
+    return JSON.stringify(order(value));
+}
+export function positiveLimit(value, fallback, name) {
+    const result = value ?? fallback;
+    if (!Number.isSafeInteger(result) || result < 1)
+        throw new RangeError(`${name} must be a positive safe integer`);
+    return result;
+}
+/** Scan nesting before JSON.parse can allocate an arbitrarily deep input. */
+export function parseCatalogJson(text, limits = {}) {
+    const maxBytes = positiveLimit(limits.maxBytes, DEFAULT_CATALOG_BYTES, "maxBytes");
+    const maxDepth = positiveLimit(limits.maxDepth, DEFAULT_CATALOG_DEPTH, "maxDepth");
+    if (maxDepth > DEFAULT_CATALOG_DEPTH)
+        throw new RangeError(`maxDepth cannot exceed the reader safety ceiling ${DEFAULT_CATALOG_DEPTH}`);
+    if (Buffer.byteLength(text, "utf8") > maxBytes)
+        throw new CatalogError("resource-limit", `Catalog exceeds ${maxBytes} UTF-8 bytes`);
+    let depth = 0, quoted = false, escaped = false, quoteStart = 0;
+    const stack = [];
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (quoted) {
+            if (escaped)
+                escaped = false;
+            else if (char === "\\")
+                escaped = true;
+            else if (char === '"') {
+                quoted = false;
+                let next = i + 1;
+                while (/[\t\r\n ]/.test(text[next] ?? "x"))
+                    next++;
+                if (text[next] === ":" && stack.at(-1)?.object) {
+                    let key;
+                    try {
+                        key = JSON.parse(text.slice(quoteStart, i + 1));
+                    }
+                    catch {
+                        throw new CatalogError("invalid-schema", "Catalog is not valid JSON");
+                    }
+                    if (stack.at(-1).keys.has(key))
+                        throw new CatalogError("invalid-schema", "Catalog contains duplicate object fields");
+                    stack.at(-1).keys.add(key);
+                }
+            }
+        }
+        else if (char === '"') {
+            quoted = true;
+            quoteStart = i;
+        }
+        else if (char === "{" || char === "[") {
+            if (++depth > maxDepth)
+                throw new CatalogError("resource-limit", `Catalog exceeds nesting depth ${maxDepth}`);
+            stack.push({ object: char === "{", keys: new Set() });
+        }
+        else if (char === "}" || char === "]") {
+            depth--;
+            stack.pop();
+        }
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new CatalogError("invalid-schema", "Catalog is not valid JSON");
+    }
+}

package/dist/compiler/catalogProvenance.d.ts

@@ -0,0 +1,15 @@
+import type { CanonicalGraph } from "./canonicalGraph.js";
+export declare const sha256: (text: string) => string;
+export declare function artifactGraph(graph: CanonicalGraph): CanonicalGraph;
+/** These display/provenance tables have no semantic child order. */
+export declare function normalizeGraphTables(result: CanonicalGraph): CanonicalGraph;
+/** Excludes source digests/locations, machine paths, documentation and loading policy. */
+export declare function semanticGraphRepresentation(graph: CanonicalGraph, options?: {
+    referenceIdentityOnly?: boolean;
+}): {
+    structure: string;
+    identities: ReadonlyMap<string, string>;
+};
+/** Fingerprinting and companion comparison share the same actual normalized structure. */
+export declare function semanticGraphFingerprint(graph: CanonicalGraph): string;
+//# sourceMappingURL=catalogProvenance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catalogProvenance.d.ts","sourceRoot":"","sources":["../../src/compiler/catalogProvenance.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,cAAc,EAAuB,MAAM,qBAAqB,CAAC;AAG9E,eAAO,MAAM,MAAM,GAAI,MAAM,MAAM,KAAG,MAAiE,CAAC;AAexG,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAqEnE;AAED,oEAAoE;AACpE,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAG3E;AAED,0FAA0F;AAC1F,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,GAAE;IAAC,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAAM,GAAG;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAC,CAmEhL;AAED,0FAA0F;AAC1F,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAEtE"}

package/dist/compiler/catalogProvenance.js

@@ -0,0 +1,229 @@
+/** Portable provenance is content-addressed; full retrieval context stays in the loading snapshot. */
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { XML_NAMESPACE, XSD_NAMESPACE, WSDL_NAMESPACE } from "../loader/orderedSyntax.js";
+import { canonicalJson, CatalogError } from "./catalogErrors.js";
+export const sha256 = (text) => createHash("sha256").update(text, "utf8").digest("hex");
+const sourceUri = (digest) => `urn:source:sha256:${digest}`;
+const artifactUri = /^(?:urn:source:sha256:|urn:base:sha256:)[a-f0-9]{64}$/;
+function baseUri(uri, source) {
+    if (artifactUri.test(uri))
+        return uri;
+    try {
+        const base = new URL(uri), document = new URL(source.uri);
+        // Relative file placement is retained as a digest; temporary root paths never leave the snapshot.
+        const relation = base.protocol === document.protocol && base.host === document.host
+            ? path.posix.relative(path.posix.dirname(document.pathname), base.pathname) : `${base.protocol}//${base.host}${base.pathname}`;
+        return `urn:base:sha256:${sha256(canonicalJson([source.digest, relation, base.search ? sha256(base.search) : ""]))}`;
+    }
+    catch {
+        throw new CatalogError("invalid-schema", "Invalid provenance URI");
+    }
+}
+export function artifactGraph(graph) {
+    const resources = new Map();
+    const collected = new WeakSet();
+    const collect = (v) => {
+        if (typeof v === "string" && /[a-z][a-z0-9+.-]*:\/\/[^\s/]*@/i.test(v))
+            throw new CatalogError("incompatible-artifact", "Credential-bearing URI cannot be serialized");
+        if (!v || typeof v !== "object")
+            return;
+        if (collected.has(v))
+            return;
+        collected.add(v);
+        if (Array.isArray(v)) {
+            for (const c of v)
+                collect(c);
+            return;
+        }
+        const o = v;
+        if (typeof o.uri === "string" && typeof o.digest === "string" && typeof o.path === "string")
+            resources.set(o.uri, o.digest);
+        for (const c of Object.values(o))
+            collect(c);
+    };
+    collect(graph);
+    const interpretation = (key) => {
+        if (artifactUri.test(key))
+            return key;
+        if (resources.has(key))
+            return sourceUri(resources.get(key));
+        try {
+            const tuple = JSON.parse(key);
+            if (!Array.isArray(tuple) || tuple.length !== 7)
+                throw Error();
+            return canonicalJson([tuple[0], sourceUri(tuple[0]), baseUri(tuple[2], { uri: tuple[1], digest: tuple[0] }), ...tuple.slice(3)]);
+        }
+        catch {
+            throw new CatalogError("invalid-schema", "Invalid loading interpretation key");
+        }
+    };
+    // Preserve immutable source/syntax sharing internally. Parent namespace and
+    // local name remain part of the key: retrieval attributes and SOAP binding
+    // addresses have different transformations/checks in different XML contexts.
+    // The data-only format-2 materialization remains byte-for-byte unchanged.
+    const transformed = new WeakMap();
+    const transform = (v, parentName) => {
+        if (!v || typeof v !== "object")
+            return v;
+        const context = parentName ? JSON.stringify([parentName.namespace, parentName.local]) : "";
+        let variants = transformed.get(v);
+        if (variants?.has(context))
+            return variants.get(context);
+        if (!variants) {
+            variants = new Map();
+            transformed.set(v, variants);
+        }
+        if (Array.isArray(v)) {
+            const result = v.map(c => transform(c, parentName));
+            variants.set(context, result);
+            return result;
+        }
+        const o = v, result = Object.create(null);
+        for (const [k, c] of Object.entries(o)) {
+            if (c === undefined)
+                continue;
+            if (k === "uri" && typeof o.digest === "string")
+                result[k] = sourceUri(o.digest);
+            else if (k === "baseUri" && o.source)
+                result[k] = baseUri(c, o.source);
+            else if (k === "interpretation" || (k === "from" && o.cycle !== undefined) || (k === "to" && o.cycle !== undefined))
+                result[k] = interpretation(c);
+            else if (k === "referenceUri" && o.source)
+                result[k] = baseUri(c, o.source);
+            else
+                result[k] = transform(c, k === "attributes" && o.kind === "element" ? o.name : undefined);
+        }
+        if (o.name && typeof o.value === "string") {
+            const a = o;
+            const bindingAddress = ["http://schemas.xmlsoap.org/wsdl/soap/", "http://schemas.xmlsoap.org/wsdl/soap12/"].includes(parentName?.namespace ?? "") && parentName?.local === "address" && a.name.local === "location";
+            if (bindingAddress) {
+                try {
+                    const endpoint = new URL(a.value);
+                    if ([...endpoint.searchParams.keys()].some(k => /token|secret|password|api[-_]?key|authorization|signature|credential/i.test(k)))
+                        throw new CatalogError("incompatible-artifact", "Credential-bearing binding URI cannot be serialized");
+                }
+                catch (e) {
+                    if (e instanceof CatalogError)
+                        throw e;
+                    throw new CatalogError("invalid-schema", "Invalid binding address URI");
+                }
+            }
+            if ((a.name.namespace === XML_NAMESPACE && a.name.local === "base") ||
+                (parentName?.namespace === XSD_NAMESPACE && ["include", "import", "redefine"].includes(parentName.local) && a.name.local === "schemaLocation") ||
+                (parentName?.namespace === XSD_NAMESPACE && parentName.local === "documentation" && a.name.local === "source") ||
+                (parentName?.namespace === WSDL_NAMESPACE && parentName.local === "import" && a.name.local === "location")) {
+                // Retrieval URI attributes are provenance; binding endpoints remain semantic syntax.
+                result.value = artifactUri.test(a.value) ? a.value : `urn:base:sha256:${sha256(a.value.replace(/\?.*$/, ""))}`;
+            }
+        }
+        variants.set(context, result);
+        return result;
+    };
+    return normalizeGraphTables(transform(graph));
+}
+/** These display/provenance tables have no semantic child order. */
+export function normalizeGraphTables(result) {
+    const origins = Object.fromEntries(Object.entries(result.origins).map(([id, values]) => [id, [...values].sort((a, b) => { const x = canonicalJson(a), y = canonicalJson(b); return x < y ? -1 : x > y ? 1 : 0; })]));
+    return { ...result, origins, nodes: [...result.nodes].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0), globals: [...result.globals].sort() };
+}
+/** Excludes source digests/locations, machine paths, documentation and loading policy. */
+export function semanticGraphRepresentation(graph, options = {}) {
+    const portable = artifactGraph(graph);
+    // Source-relative scoped IDs remain artifact identity. Fingerprint-only IDs follow semantic
+    // containment instead, so inserting documentation cannot change their identity or table order.
+    const ids = new Map(), paths = new Map();
+    const nodes = new Map(portable.nodes.map(n => [n.id, n]));
+    const children = (n) => {
+        const result = [];
+        const ref = (r, edge) => { if (r?.kind === "local")
+            result.push([r.target, edge]); };
+        if (n.kind === "element" || n.kind === "attribute")
+            ref(n.type, "type");
+        if (n.kind === "element")
+            ref(n.substitutionGroup, "substitutionGroup");
+        if (n.kind === "attributeUse")
+            ref(n.declaration, "declaration");
+        if (n.kind === "attributeGroupUse")
+            ref(n.reference, "attributeGroup");
+        if (n.kind === "particle") {
+            if (n.term.kind === "element")
+                ref(n.term.declaration, "declaration");
+            else if (n.term.kind === "group")
+                ref(n.term.reference, "group");
+            else if (n.term.kind === "sequence" || n.term.kind === "choice" || n.term.kind === "all")
+                n.term.children.forEach((id, i) => result.push([id, `children/${i}`]));
+        }
+        if (n.kind === "group" || n.kind === "complexType") {
+            if (n.content)
+                result.push([n.content, "content"]);
+        }
+        if (n.kind === "attributeGroup" || n.kind === "complexType")
+            n.attributes.forEach((id, i) => result.push([id, `attributes/${i}`]));
+        if (n.kind === "complexType") {
+            ref(n.derivation?.base, "base");
+            ref(n.derivation?.inlineType, "inlineType");
+        }
+        if (n.kind === "simpleType") {
+            if (n.variety.kind === "restriction")
+                ref(n.variety.base, "base");
+            else if (n.variety.kind === "list")
+                ref(n.variety.item, "item");
+            else
+                n.variety.members.forEach((r, i) => ref(r, `members/${i}`));
+        }
+        return result;
+    };
+    const stack = portable.globals.map(id => ({ id, path: id }));
+    while (stack.length) {
+        const item = stack.pop(), n = nodes.get(item.id);
+        if (ids.has(n.id))
+            continue;
+        const id = n.identity.kind === "global" ? n.id : `semantic:${sha256(item.path)}`;
+        ids.set(n.id, id);
+        paths.set(n.id, item.path);
+        for (const [child, edge] of children(n))
+            stack.push({ id: child, path: `${item.path}/${edge}` });
+    }
+    const mappedId = (id) => ids.get(id);
+    const reference = (r) => r.kind === "local" ? { ...r, target: mappedId(r.target) } : r;
+    const mapNode = (n) => {
+        const common = { ...n, id: mappedId(n.id), identity: n.identity.kind === "scoped" ? { ...n.identity, owner: mappedId(n.identity.owner), path: paths.get(n.id) } : n.identity };
+        switch (n.kind) {
+            case "element": return { ...common, kind: n.kind, name: n.name, type: reference(n.type), nillable: n.nillable, abstract: n.abstract, value: n.value, substitutionGroup: n.substitutionGroup ? reference(n.substitutionGroup) : undefined };
+            case "attribute": return { ...common, kind: n.kind, name: n.name, type: reference(n.type), value: n.value };
+            case "attributeUse": return { ...common, kind: n.kind, declaration: reference(n.declaration), use: n.use, value: n.value };
+            case "particle": return { ...common, kind: n.kind, occurs: n.occurs, term: n.term.kind === "element" ? { ...n.term, declaration: reference(n.term.declaration) } : n.term.kind === "group" ? { ...n.term, reference: reference(n.term.reference) } : n.term.kind === "sequence" || n.term.kind === "choice" || n.term.kind === "all" ? { ...n.term, children: n.term.children.map(mappedId) } : n.term };
+            case "group": return { ...common, kind: n.kind, content: mappedId(n.content) };
+            case "attributeGroup": return { ...common, kind: n.kind, attributes: n.attributes.map(mappedId) };
+            case "complexType": return { ...common, kind: n.kind, mixed: n.mixed, abstract: n.abstract, content: n.content ? mappedId(n.content) : undefined, attributes: n.attributes.map(mappedId), derivation: n.derivation ? { ...n.derivation, base: reference(n.derivation.base), inlineType: n.derivation.inlineType ? reference(n.derivation.inlineType) : undefined } : undefined };
+            case "simpleType": return { ...common, kind: n.kind, variety: n.variety.kind === "restriction" ? { ...n.variety, base: reference(n.variety.base) } : n.variety.kind === "list" ? { ...n.variety, item: reference(n.variety.item) } : { ...n.variety, members: n.variety.members.map(reference) } };
+            case "attributeGroupUse": return { ...common, kind: n.kind, reference: reference(n.reference) };
+            case "attributeWildcard": return { ...common, kind: n.kind, wildcard: n.wildcard };
+            case "wsdl": return { ...common, kind: n.kind, name: n.name, role: n.role, syntax: n.syntax, references: n.references };
+        }
+    };
+    const stable = { ...portable, nodes: portable.nodes.map(mapNode).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0) };
+    const omit = new Set(["source", "uri", "digest", "baseUri", "origins", "loading", "schemaAnnotations", "annotations", "lexicalName"]);
+    const semantic = (v, parentName) => {
+        if (Array.isArray(v))
+            return v.filter(c => !(c && typeof c === "object" && ((c.name?.local === "annotation" && c.name?.namespace === XSD_NAMESPACE) || (c.name?.local === "documentation" && [XSD_NAMESPACE, WSDL_NAMESPACE].includes(c.name?.namespace))))).map(c => semantic(c, parentName)).filter(c => c !== undefined);
+        if (!v || typeof v !== "object")
+            return v;
+        const o = v;
+        if (o.kind === "text" && typeof o.value === "string" && !/[^\t\r\n ]/.test(o.value) && [XSD_NAMESPACE, WSDL_NAMESPACE].includes(parentName?.namespace ?? ""))
+            return undefined;
+        if (o.kind === "symbol" || o.kind === "builtin")
+            return Object.fromEntries(Object.entries(o).filter(([k]) => k !== "lexical" && !(options.referenceIdentityOnly && k === "target")).map(([k, c]) => [k, semantic(c)]));
+        if (o.name && typeof o.value === "string" && o.name.namespace === XML_NAMESPACE && o.name.local === "base")
+            return undefined;
+        if (o.name && typeof o.value === "string" && o.name.namespace === "" && o.name.local === "schemaLocation" && parentName?.namespace === XSD_NAMESPACE && ["include", "import"].includes(parentName.local))
+            return undefined;
+        return Object.fromEntries(Object.entries(o).filter(([k]) => !omit.has(k) && !(k === "path" && Object.hasOwn(o, "reference") && Object.hasOwn(o, "attribute"))).map(([k, c]) => [k, semantic(c, ["children", "attributes"].includes(k) && o.kind === "element" ? o.name : undefined)]));
+    };
+    return { structure: canonicalJson(semantic(stable)), identities: ids };
+}
+/** Fingerprinting and companion comparison share the same actual normalized structure. */
+export function semanticGraphFingerprint(graph) {
+    return sha256(semanticGraphRepresentation(graph).structure);
+}