@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/loader/orderedSyntax.d.ts

@@ -0,0 +1,77 @@
+export declare const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+export declare const XSD_NAMESPACE = "http://www.w3.org/2001/XMLSchema";
+export declare const WSDL_NAMESPACE = "http://schemas.xmlsoap.org/wsdl/";
+export declare const DEFAULT_SYNTAX_DEPTH = 256;
+export type ExpandedName = Readonly<{
+    namespace: string;
+    local: string;
+}>;
+export type SourcePosition = Readonly<{
+    offset: number;
+    line: number;
+    column: number;
+}>;
+export type SyntaxSource = Readonly<{
+    uri: string;
+    digest: string;
+    path: string;
+    start: SourcePosition;
+    end: SourcePosition;
+}>;
+export type SyntaxAttribute = Readonly<{
+    name: ExpandedName;
+    lexicalName: string;
+    value: string;
+}>;
+export type SyntaxText = Readonly<{
+    kind: "text";
+    value: string;
+    source: SyntaxSource;
+}>;
+export type SyntaxElement = Readonly<{
+    kind: "element";
+    name: ExpandedName;
+    lexicalName: string;
+    attributes: readonly SyntaxAttribute[];
+    namespaces: Readonly<Record<string, string>>;
+    baseUri: string;
+    children: readonly SyntaxNode[];
+    source: SyntaxSource;
+}>;
+export type SyntaxNode = SyntaxElement | SyntaxText;
+export type SyntaxDocument = Readonly<{
+    uri: string;
+    digest: string;
+    root: SyntaxElement;
+}>;
+export type LoadingErrorCategory = "invalid-schema" | "unsupported-capability" | "resource-limit" | "transport";
+export declare class SchemaLoadingError extends Error {
+    readonly category: LoadingErrorCategory;
+    readonly source?: SyntaxSource | undefined;
+    constructor(category: LoadingErrorCategory, message: string, source?: SyntaxSource | undefined);
+}
+export declare function syntaxAttribute(node: SyntaxElement, local: string, namespace?: string): string | undefined;
+export declare function syntaxElements(node: SyntaxElement, namespace?: string, local?: string): SyntaxElement[];
+/** One range authority for name predicates and the private fixed-S4S pattern consumer. */
+export declare const XML_NAME_RANGES: Readonly<{
+    start: string;
+    character: string;
+}>;
+/** Shared XML name grammar for loader QNames and schema-declared operands. */
+export declare const isXmlNCName: (value: string) => boolean;
+export declare const isXmlName: (value: string) => boolean;
+export declare const isXmlNmtoken: (value: string) => boolean;
+export declare function resolveLexicalQName(lexical: string, node: SyntaxElement): ExpandedName;
+/** Positions are one-based lines/columns and zero-based UTF-16 offsets in decoded XML. */
+export interface OrderedSyntaxOptions {
+    maxDepth?: number;
+    /** Optional bounded runtime boundary; legacy schema callers retain their policy. */
+    maxBytes?: number;
+    maxNodes?: number;
+    maxText?: number;
+    xml10Only?: boolean;
+    chargeWork?: (amount: number) => void;
+    reserveNode?: () => void;
+}
+export declare function parseOrderedSyntax(bytes: Uint8Array, uri: string, options?: OrderedSyntaxOptions): SyntaxDocument;
+//# sourceMappingURL=orderedSyntax.d.ts.map

package/dist/loader/orderedSyntax.d.ts.map

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

package/dist/loader/orderedSyntax.js

@@ -0,0 +1,202 @@
+/** Ordered XML syntax boundary for the unreleased faithful compiler. */
+import { createHash } from "node:crypto";
+import { SaxesParser } from "saxes";
+export const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+export const XSD_NAMESPACE = "http://www.w3.org/2001/XMLSchema";
+export const WSDL_NAMESPACE = "http://schemas.xmlsoap.org/wsdl/";
+export const DEFAULT_SYNTAX_DEPTH = 256;
+export class SchemaLoadingError extends Error {
+    category;
+    source;
+    constructor(category, message, source) {
+        super(message);
+        this.category = category;
+        this.source = source;
+        this.name = "SchemaLoadingError";
+    }
+}
+export function syntaxAttribute(node, local, namespace = "") {
+    return node.attributes.find(a => a.name.local === local && a.name.namespace === namespace)?.value;
+}
+export function syntaxElements(node, namespace, local) {
+    return node.children.filter((n) => n.kind === "element"
+        && (namespace === undefined || n.name.namespace === namespace)
+        && (local === undefined || n.name.local === local));
+}
+// XML 1.0 (fifth edition) NCName; QName values use default namespaces, attributes do not.
+const ncStart = "A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}";
+/** One range authority for name predicates and the private fixed-S4S pattern consumer. */
+export const XML_NAME_RANGES = Object.freeze({ start: ncStart + ':',
+    character: ncStart + ':\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040' });
+const ncName = new RegExp(`^[${ncStart}][${ncStart}\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$`, "u");
+/** Shared XML name grammar for loader QNames and schema-declared operands. */
+export const isXmlNCName = (value) => ncName.test(value);
+const xmlName = new RegExp(`^[${XML_NAME_RANGES.start}][${XML_NAME_RANGES.character}]*$`, "u");
+const xmlNmtoken = new RegExp(`^[${XML_NAME_RANGES.character}]+$`, "u");
+export const isXmlName = (value) => xmlName.test(value);
+export const isXmlNmtoken = (value) => xmlNmtoken.test(value);
+export function resolveLexicalQName(lexical, node) {
+    const parts = lexical.replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, "").split(":");
+    if (parts.length > 2 || parts.some(p => !ncName.test(p))) {
+        throw new SchemaLoadingError("invalid-schema", "Invalid lexical QName", node.source);
+    }
+    const prefix = parts.length === 2 ? parts[0] : "";
+    const namespace = node.namespaces[prefix];
+    if (prefix && !namespace)
+        throw new SchemaLoadingError("invalid-schema", "Unbound QName prefix", node.source);
+    return Object.freeze({ namespace: namespace ?? "", local: parts.at(-1) });
+}
+function decodeXml(bytes, strictBom = false) {
+    const encoding = bytes[0] === 0xff && bytes[1] === 0xfe ? "utf-16le"
+        : bytes[0] === 0xfe && bytes[1] === 0xff ? "utf-16be" : "utf-8";
+    try {
+        const text = new TextDecoder(encoding, { fatal: true }).decode(bytes);
+        if (strictBom && text.startsWith('\ufeff'))
+            throw new SchemaLoadingError('invalid-schema', 'Multiple XML byte order marks');
+        const declared = /^<\?xml\s[^?]*encoding\s*=\s*["']([^"']+)["']/i.exec(text)?.[1].toLowerCase();
+        if (declared && !(encoding === "utf-8" ? ["utf-8", "utf8"] : ["utf-16", encoding]).includes(declared)) {
+            throw new SchemaLoadingError("unsupported-capability", "Unsupported XML byte encoding");
+        }
+        return text;
+    }
+    catch (error) {
+        if (error instanceof SchemaLoadingError)
+            throw error;
+        throw new SchemaLoadingError("invalid-schema", "Invalid XML byte encoding");
+    }
+}
+export function parseOrderedSyntax(bytes, uri, options = {}) {
+    const maxDepth = options.maxDepth ?? DEFAULT_SYNTAX_DEPTH;
+    if (!Number.isSafeInteger(maxDepth) || maxDepth < 1)
+        throw new RangeError("maxDepth must be a positive safe integer");
+    for (const key of ['maxBytes', 'maxNodes', 'maxText']) {
+        const value = options[key];
+        if (value !== undefined && (!Number.isSafeInteger(value) || value < 1))
+            throw new RangeError(`${key} must be a positive safe integer`);
+    }
+    try {
+        new URL(uri);
+    }
+    catch {
+        throw new SchemaLoadingError("invalid-schema", "An absolute source URI is required");
+    }
+    if (options.maxBytes !== undefined && bytes.byteLength > options.maxBytes)
+        throw new SchemaLoadingError('resource-limit', 'XML byte limit');
+    // Reserve decoding, hash, line index and SAX token buffers before their bulk
+    // intrinsics. Tokens (including ignored comments/PI/DTD) are bounded by bytes.
+    const charge = (amount) => options.chargeWork?.(amount);
+    charge(4096 + bytes.byteLength * 64);
+    const digest = createHash("sha256").update(bytes).digest("hex");
+    const text = decodeXml(bytes, options.xml10Only);
+    const lines = [0];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === "\r") {
+            if (text[i + 1] === "\n")
+                i++;
+            lines.push(i + 1);
+        }
+        else if (text[i] === "\n")
+            lines.push(i + 1);
+    }
+    const position = (offset) => {
+        let low = 0, high = lines.length;
+        while (low + 1 < high) {
+            const mid = (low + high) >>> 1;
+            if (lines[mid] <= offset)
+                low = mid;
+            else
+                high = mid;
+        }
+        return Object.freeze({ offset, line: low + 1, column: offset - lines[low] + 1 });
+    };
+    const source = (path, start, end) => Object.freeze({ uri, digest, path, start: position(start), end: position(end) });
+    const stack = [];
+    let root;
+    let tagStart = 0, cursor = 0;
+    const parser = new SaxesParser({ xmlns: true });
+    let nodes = 0, textUnits = 0;
+    const fail = (category, message) => {
+        throw new SchemaLoadingError(category, message, source(stack.at(-1)?.source.path ?? "/0", tagStart, parser.position));
+    };
+    parser.on("error", () => fail("invalid-schema", "Malformed XML or unresolved entity reference"));
+    parser.on("doctype", () => fail("unsupported-capability", "DTDs and entity declarations are forbidden"));
+    parser.on('xmldecl', declaration => {
+        if (options.xml10Only && declaration.version !== '1.0')
+            fail('unsupported-capability', 'Only XML 1.0 is supported');
+    });
+    const reserveNode = () => {
+        charge(512);
+        if (options.maxNodes !== undefined && nodes >= options.maxNodes)
+            fail('resource-limit', 'XML node limit');
+        options.reserveNode?.();
+        nodes++;
+    };
+    parser.on("opentagstart", () => { tagStart = text.lastIndexOf("<", parser.position - 1); });
+    parser.on("opentag", tag => {
+        if (stack.length >= maxDepth)
+            fail("resource-limit", `XML syntax depth exceeds ${maxDepth} elements`);
+        const parent = stack.at(-1);
+        reserveNode();
+        // Inherited maps/path copies can be larger than the current lexical tag.
+        charge(512 + (parent?.source.path.length ?? 0) * 4);
+        for (const prefix in parent?.namespaces)
+            charge(128 + (prefix.length + parent.namespaces[prefix].length) * 4);
+        for (const prefix in tag.ns)
+            if (Object.hasOwn(tag.ns, prefix))
+                charge(128 + (prefix.length + tag.ns[prefix].length) * 4);
+        const attributes = Object.values(tag.attributes).filter(a => a.uri !== "http://www.w3.org/2000/xmlns/")
+            .map(a => Object.freeze({ name: Object.freeze({ namespace: a.uri, local: a.local }), lexicalName: a.name, value: a.value }));
+        const namespaces = Object.freeze(Object.assign(Object.create(null), parent?.namespaces ?? { xml: XML_NAMESPACE, "": "" }, tag.ns));
+        const base = attributes.find(a => a.name.namespace === XML_NAMESPACE && a.name.local === "base")?.value;
+        let baseUri;
+        // Relative xml:base resolution may copy an inherited URI much larger than
+        // this tag. Charge its input/output envelope before the URL intrinsic.
+        if (base !== undefined)
+            charge(512 + (base.length + (parent?.baseUri ?? uri).length) * 16);
+        try {
+            baseUri = base === undefined ? parent?.baseUri ?? uri : new URL(base, parent?.baseUri ?? uri).href;
+        }
+        catch {
+            return fail("invalid-schema", "Invalid xml:base URI");
+        }
+        const node = { kind: "element", name: Object.freeze({ namespace: tag.uri, local: tag.local }), lexicalName: tag.name,
+            attributes: Object.freeze(attributes), namespaces, baseUri, children: [], source: source(parent ? `${parent.source.path}/${parent.children.length}` : "/0", tagStart, parser.position) };
+        if (parent)
+            parent.children.push(node);
+        else
+            root = node;
+        stack.push(node);
+        cursor = parser.position;
+    });
+    const appendText = (value, start, end) => {
+        const parent = stack.at(-1);
+        if (parent) {
+            if (options.maxText !== undefined && value.length > options.maxText - textUnits)
+                fail('resource-limit', 'XML text limit');
+            textUnits += value.length;
+            reserveNode();
+            charge(512 + value.length * 4 + parent.source.path.length * 4);
+            parent.children.push(Object.freeze({ kind: "text", value, source: source(`${parent.source.path}/${parent.children.length}`, start, end) }));
+        }
+    };
+    parser.on("text", value => { const end = text[parser.position - 1] === "<" ? parser.position - 1 : parser.position; appendText(value, cursor, end); cursor = end; });
+    parser.on("cdata", value => { appendText(value, cursor + 9, parser.position - 3); cursor = parser.position; });
+    parser.on("comment", () => { cursor = parser.position + 1; });
+    parser.on("processinginstruction", () => { cursor = parser.position; });
+    parser.on("closetag", () => {
+        const node = stack.pop();
+        node.source = source(node.source.path, node.source.start.offset, parser.position);
+        Object.freeze(node.children);
+        Object.freeze(node);
+        cursor = parser.position;
+    });
+    // Bounded cooperative checkpoints even while a SAX token is buffered.
+    for (let offset = 0; offset < text.length; offset += 1024) {
+        charge(1024);
+        parser.write(text.slice(offset, offset + 1024));
+    }
+    parser.close();
+    if (!root)
+        fail("invalid-schema", "Missing XML root element");
+    return Object.freeze({ uri, digest, root: root });
+}

package/dist/loader/resolutionDepth.d.ts

@@ -0,0 +1,7 @@
+/** Polynomial upper bound for cached resolution depth, including cycle closure. */
+export type ResolutionArc = Readonly<{
+    to: string;
+    cost: 0 | 1;
+}>;
+export declare function resolutionDepthBound(root: string, graph: ReadonlyMap<string, readonly ResolutionArc[]>, terminals: ReadonlySet<string>): number;
+//# sourceMappingURL=resolutionDepth.d.ts.map

package/dist/loader/resolutionDepth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolutionDepth.d.ts","sourceRoot":"","sources":["../../src/loader/resolutionDepth.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAA;CAAC,CAAC,CAAC;AAEhE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAyD/I"}

package/dist/loader/resolutionDepth.js

@@ -0,0 +1,65 @@
+export function resolutionDepthBound(root, graph, terminals) {
+    const arcs = (key) => terminals.has(key) ? [] : graph.get(key) ?? [];
+    const seen = new Set();
+    const order = [];
+    const stack = [{ key: root, exit: false }];
+    const reverse = new Map();
+    while (stack.length) {
+        const { key, exit } = stack.pop();
+        if (exit) {
+            order.push(key);
+            continue;
+        }
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        stack.push({ key, exit: true });
+        for (const edge of arcs(key)) {
+            const incoming = reverse.get(edge.to) ?? [];
+            incoming.push(key);
+            reverse.set(edge.to, incoming);
+            stack.push({ key: edge.to, exit: false });
+        }
+    }
+    const component = new Map();
+    const groups = [];
+    for (const rootKey of order.reverse()) {
+        if (component.has(rootKey))
+            continue;
+        const index = groups.length;
+        const members = [];
+        const pending = [rootKey];
+        while (pending.length) {
+            const key = pending.pop();
+            if (component.has(key))
+                continue;
+            component.set(key, index);
+            members.push(key);
+            for (const previous of reverse.get(key) ?? [])
+                pending.push(previous);
+        }
+        groups.push(members);
+    }
+    const internal = new Map();
+    const weights = groups.map((members, index) => members.reduce((sum, key) => {
+        const cost = arcs(key).reduce((max, edge) => component.get(edge.to) === index ? Math.max(max, edge.cost) : max, 0);
+        internal.set(key, cost);
+        return sum + cost;
+    }, 0));
+    // SCC indices follow source-to-sink order, so all exit heights are already known.
+    const heights = groups.map(() => 0);
+    for (let index = groups.length - 1; index >= 0; index--) {
+        let height = weights[index];
+        for (const key of groups[index]) {
+            for (const edge of arcs(key)) {
+                const target = component.get(edge.to);
+                if (target !== index) {
+                    // An exit replaces that node's internal edge, rather than closing then exiting.
+                    height = Math.max(height, weights[index] - internal.get(key) + edge.cost + heights[target]);
+                }
+            }
+        }
+        heights[index] = height;
+    }
+    return heights[component.get(root)];
+}

package/dist/loader/schemaInput.d.ts

@@ -0,0 +1,53 @@
+import type { SyntaxDocument, SyntaxElement, SyntaxSource } from "./orderedSyntax.js";
+import type { LoadingLimits, OfflineSchemaResource, ResourceMetadata, SchemaResourcePolicy } from "./schemaResources.js";
+export type SchemaContext = Readonly<{
+    kind: "root" | "inline" | "include" | "import";
+    namespace: string;
+}>;
+export type SchemaInterpretation = Readonly<{
+    key: string;
+    syntax: SyntaxElement;
+    documentUri: string;
+    digest: string;
+    baseUri: string;
+    targetNamespace: string;
+    context: SchemaContext;
+}>;
+export type ResolutionEdge = Readonly<{
+    kind: "include" | "import" | "wsdl-import";
+    from: string;
+    to?: string;
+    referenceUri?: string;
+    source: SyntaxSource;
+    cycle: boolean;
+}>;
+export type SchemaInput = Readonly<{
+    root: SyntaxDocument;
+    documents: readonly SyntaxDocument[];
+    schemas: readonly SchemaInterpretation[];
+    resources: readonly ResourceMetadata[];
+    edges: readonly ResolutionEdge[];
+    limits: LoadingLimits;
+    metrics: Readonly<{
+        resources: number;
+        totalBytes: number;
+        ioMs: number;
+    }>;
+}>;
+/** Internal bridge for one retained-source invocation. Returned bytes are data, not authority. */
+export declare function copyOriginalSchemaResource(input: SchemaInput, uri: string, chargeWork: (amount: number) => void): Uint8Array;
+export declare function assertLoadedSchemaInput(input: SchemaInput): void;
+export declare function schemaInterpretationKey(node: SyntaxElement, targetNamespace: string, context: SchemaContext): string;
+export type SchemaInputOptions = {
+    signal?: AbortSignal;
+    /** Optional request accounting used by the additive assessment boundary. */
+    chargeWork?: (amount: number) => void;
+    policy: SchemaResourcePolicy;
+    limits?: Partial<LoadingLimits>;
+    offlineResources?: ReadonlyMap<string, OfflineSchemaResource>;
+};
+/** A fresh compilation-scoped snapshot, with no implicit network or filesystem permission. */
+export declare function loadSchemaInput(source: string, options: SchemaInputOptions): Promise<SchemaInput>;
+/** Internal faithful source entry; preserves syntax and the legacy public entry. */
+export declare function loadSemanticSchemaInput(source: string, options: SchemaInputOptions): Promise<SchemaInput>;
+//# sourceMappingURL=schemaInput.d.ts.map

package/dist/loader/schemaInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaInput.d.ts","sourceRoot":"","sources":["../../src/loader/schemaInput.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,cAAc,EAAE,aAAa,EAAE,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAEpF,OAAO,KAAK,EAAC,aAAa,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAKvH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AAC1G,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,aAAa,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,aAAa,CAAC;CACxB,CAAC,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,aAAa,CAAC;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC;IACjC,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,SAAS,cAAc,EAAE,CAAC;IACrC,OAAO,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACzC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACvC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IACjC,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,QAAQ,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;CAC1E,CAAC,CAAC;AAMH,kGAAkG;AAClG,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,UAAU,CAM5H;AACD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAEhE;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,MAAM,CAEpH;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IAChC,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;CAC/D,CAAC;AAEF,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC,CAEjG;AAED,oFAAoF;AACpF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC,CAEzG"}

package/dist/loader/schemaInput.js

@@ -0,0 +1,212 @@
+/** Contextual schema traversal; consumes ordered syntax, never payload hints. */
+import { parseOrderedSyntax, SchemaLoadingError, syntaxAttribute, syntaxElements, XSD_NAMESPACE, WSDL_NAMESPACE } from "./orderedSyntax.js";
+import { SchemaResourceLoader, resolveResourceUri } from "./schemaResources.js";
+import { resolutionDepthBound } from "./resolutionDepth.js";
+import { normalizeWhitespace } from '../util/xmlWhitespace.js';
+// Source-syntax evidence is issued only by this loader, never by a copied shape.
+const loadedInputs = new WeakSet();
+// Private original authorized snapshot; never reconstructed from syntax/digests.
+const originalSources = new WeakMap();
+/** Internal bridge for one retained-source invocation. Returned bytes are data, not authority. */
+export function copyOriginalSchemaResource(input, uri, chargeWork) {
+    assertLoadedSchemaInput(input);
+    const bytes = originalSources.get(input)?.get(uri);
+    if (!bytes)
+        throw new TypeError('Original semantic source bytes unavailable');
+    chargeWork(512 + bytes.byteLength * 8);
+    return new Uint8Array(bytes);
+}
+export function assertLoadedSchemaInput(input) {
+    if (!loadedInputs.has(input))
+        throw new TypeError("Unauthenticated loaded schema input");
+}
+export function schemaInterpretationKey(node, targetNamespace, context) {
+    return JSON.stringify([node.source.digest, node.source.uri, node.baseUri, targetNamespace, context.kind, context.namespace, node.source.path]);
+}
+/** A fresh compilation-scoped snapshot, with no implicit network or filesystem permission. */
+export function loadSchemaInput(source, options) {
+    return loadSchemaInputWithValues(source, options, false);
+}
+/** Internal faithful source entry; preserves syntax and the legacy public entry. */
+export function loadSemanticSchemaInput(source, options) {
+    return loadSchemaInputWithValues(source, options, true);
+}
+async function loadSchemaInputWithValues(source, options, semanticValues) {
+    const loader = await SchemaResourceLoader.create(options.policy, options.limits, options.offlineResources, options.chargeWork, options.signal);
+    const documents = new Map();
+    const originalBytes = new Map();
+    const schemas = new Map();
+    const edges = [];
+    const active = new Set();
+    const wsdlVisited = new Set();
+    const depthGraph = new Map();
+    const depthTargets = new Map();
+    const recordDepthArc = (from, to, cost) => {
+        const target = JSON.stringify([to, cost]);
+        const targets = depthTargets.get(from) ?? new Set();
+        if (targets.has(target))
+            return;
+        targets.add(target);
+        depthTargets.set(from, targets);
+        const arcs = depthGraph.get(from) ?? [];
+        arcs.push({ to, cost });
+        depthGraph.set(from, arcs);
+    };
+    const recordEdge = (edge) => {
+        options.chargeWork?.(256);
+        const frozen = Object.freeze(edge);
+        edges.push(frozen);
+        if (edge.to)
+            recordDepthArc(edge.from, edge.to, 1);
+    };
+    const checkDepth = (depth, node) => {
+        if (depth > loader.limits.resolutionDepth)
+            throw new SchemaLoadingError("resource-limit", `Schema resolution depth exceeds ${loader.limits.resolutionDepth} edges`, node?.source);
+    };
+    const getDocument = async (uri) => {
+        const resource = await loader.fetchResource(uri);
+        let doc = documents.get(resource.uri);
+        if (!doc) {
+            doc = parseOrderedSyntax(resource.bytes, resource.uri, { maxDepth: loader.limits.syntaxDepth });
+            if (semanticValues) {
+                options.chargeWork?.(128);
+                originalBytes.set(resource.uri, resource.bytes);
+            }
+            documents.set(resource.uri, doc);
+        }
+        return doc;
+    };
+    const is = (node, namespace, local) => node.name.namespace === namespace && node.name.local === local;
+    // Only XSD anyURI properties use this mapping. Original syntax and namespace
+    // bindings, WSDL transport names, and arbitrary resource URLs remain intact.
+    // Source byte/resource limits govern this phase, before semantic preparation.
+    const xsdUri = (node, name) => {
+        const value = syntaxAttribute(node, name);
+        options.chargeWork?.(64 + (value?.length ?? 0) * 16);
+        return value === undefined || !semanticValues ? value : normalizeWhitespace(value, 'collapse');
+    };
+    // Cached interpretations still consume resolution depth on a later, deeper route.
+    const checkCachedDepth = (key, depth) => {
+        if (depth + resolutionDepthBound(key, depthGraph, active) > loader.limits.resolutionDepth) {
+            throw new SchemaLoadingError("resource-limit", `Schema resolution depth exceeds ${loader.limits.resolutionDepth} edges`, schemas.get(key)?.syntax.source ?? documents.get(key)?.root.source);
+        }
+    };
+    const referencedDocument = async (reference, node) => {
+        try {
+            const referenceUri = resolveResourceUri(reference, node.baseUri);
+            return { referenceUri, doc: await getDocument(referenceUri) };
+        }
+        catch (error) {
+            if (error instanceof SchemaLoadingError && !error.source)
+                throw new SchemaLoadingError(error.category, error.message, node.source);
+            throw error;
+        }
+    };
+    const interpret = async (node, context, depth) => {
+        options.chargeWork?.(4096 + (node.source.path.length + node.source.uri.length + node.baseUri.length + context.namespace.length) * 32 + node.children.length * 128);
+        checkDepth(depth, node);
+        if (!is(node, XSD_NAMESPACE, "schema"))
+            throw new SchemaLoadingError("invalid-schema", "Expected an XSD schema root", node.source);
+        const declaredValue = xsdUri(node, "targetNamespace");
+        if (semanticValues && declaredValue === '')
+            throw new SchemaLoadingError("invalid-schema", "A present schema target namespace must not be empty", node.source);
+        const declaredNamespace = declaredValue ?? "";
+        const targetNamespace = context.kind === "include" && !declaredNamespace ? context.namespace : declaredNamespace;
+        if (context.kind === "include" && declaredNamespace && declaredNamespace !== context.namespace) {
+            throw new SchemaLoadingError("invalid-schema", "Included schema target namespace differs from its including schema", node.source);
+        }
+        if (context.kind === "import" && targetNamespace !== context.namespace) {
+            throw new SchemaLoadingError("invalid-schema", "Imported schema target namespace differs from the declared import namespace", node.source);
+        }
+        const key = schemaInterpretationKey(node, targetNamespace, context);
+        if (schemas.has(key)) {
+            if (!active.has(key))
+                checkCachedDepth(key, depth);
+            return key;
+        }
+        const instance = Object.freeze({ key, syntax: node, documentUri: node.source.uri, digest: node.source.digest, baseUri: node.baseUri, targetNamespace, context: Object.freeze(context) });
+        schemas.set(key, instance);
+        active.add(key);
+        for (const child of syntaxElements(node, XSD_NAMESPACE)) {
+            if (child.name.local !== "include" && child.name.local !== "import")
+                continue;
+            const kind = child.name.local;
+            const location = xsdUri(child, "schemaLocation");
+            const importedNamespace = xsdUri(child, "namespace");
+            const missingLocation = semanticValues ? location === undefined : !location;
+            if (missingLocation && kind === "include")
+                throw new SchemaLoadingError("invalid-schema", "Schema include requires schemaLocation", child.source);
+            if (missingLocation) {
+                recordEdge({ kind, from: key, source: child.source, cycle: false });
+                continue;
+            }
+            checkDepth(depth + 1, child);
+            const namespace = kind === "include" ? targetNamespace : importedNamespace ?? "";
+            if (kind === "import" && namespace === targetNamespace)
+                throw new SchemaLoadingError("invalid-schema", "Schema import must name a different namespace", child.source);
+            const { referenceUri, doc } = await referencedDocument(location, child);
+            const childDeclaredNamespace = xsdUri(doc.root, "targetNamespace");
+            // A successfully supplied import referent must match both presence and
+            // value. An explicit empty import namespace without a referent is not
+            // by itself forbidden by the anyURI datatype or src-import clause 3.
+            if (semanticValues && kind === 'import' && (importedNamespace === undefined) !== (childDeclaredNamespace === undefined)) {
+                throw new SchemaLoadingError("invalid-schema", "Imported schema target namespace presence differs from the declared import namespace", child.source);
+            }
+            const childContext = { kind, namespace };
+            const childNamespace = kind === "include" ? childDeclaredNamespace || namespace : childDeclaredNamespace ?? "";
+            const childKey = schemaInterpretationKey(doc.root, childNamespace, childContext);
+            const cycle = active.has(childKey);
+            const to = await interpret(doc.root, childContext, depth + 1);
+            recordEdge({ kind, from: key, to, referenceUri, source: child.source, cycle });
+        }
+        active.delete(key);
+        return key;
+    };
+    const visitWsdl = async (doc, depth) => {
+        checkDepth(depth, doc.root);
+        if (!is(doc.root, WSDL_NAMESPACE, "definitions"))
+            throw new SchemaLoadingError("invalid-schema", "Expected WSDL 1.1 definitions", doc.root.source);
+        if (wsdlVisited.has(doc.uri)) {
+            if (!active.has(doc.uri))
+                checkCachedDepth(doc.uri, depth);
+            return;
+        }
+        wsdlVisited.add(doc.uri);
+        active.add(doc.uri);
+        for (const child of syntaxElements(doc.root, WSDL_NAMESPACE)) {
+            if (child.name.local === "types") {
+                for (const schema of syntaxElements(child, XSD_NAMESPACE, "schema")) {
+                    const key = await interpret(schema, { kind: "inline", namespace: "" }, depth);
+                    recordDepthArc(doc.uri, key, 0);
+                }
+            }
+            else if (child.name.local === "import") {
+                const location = syntaxAttribute(child, "location");
+                if (!location)
+                    throw new SchemaLoadingError("invalid-schema", "WSDL import requires location", child.source);
+                checkDepth(depth + 1, child);
+                const { referenceUri, doc: imported } = await referencedDocument(location, child);
+                if ((syntaxAttribute(imported.root, "targetNamespace") ?? "") !== (syntaxAttribute(child, "namespace") ?? "")) {
+                    throw new SchemaLoadingError("invalid-schema", "WSDL import namespace mismatch", child.source);
+                }
+                const cycle = active.has(imported.uri);
+                await visitWsdl(imported, depth + 1);
+                recordEdge({ kind: "wsdl-import", from: doc.uri, to: imported.uri, referenceUri, source: child.source, cycle });
+            }
+        }
+        active.delete(doc.uri);
+    };
+    const root = await getDocument(resolveResourceUri(source));
+    if (is(root.root, XSD_NAMESPACE, "schema"))
+        await interpret(root.root, { kind: "root", namespace: "" }, 0);
+    else if (is(root.root, WSDL_NAMESPACE, "definitions"))
+        await visitWsdl(root, 0);
+    else
+        throw new SchemaLoadingError("unsupported-capability", "Only WSDL 1.1 or XSD schema inputs are accepted; payload hints cannot resolve schemas", root.root.source);
+    const input = Object.freeze({ root, documents: Object.freeze([...documents.values()]), schemas: Object.freeze([...schemas.values()]),
+        resources: loader.metadata, edges: Object.freeze(edges), limits: loader.limits, metrics: loader.metrics });
+    loadedInputs.add(input);
+    if (semanticValues)
+        originalSources.set(input, originalBytes);
+    return input;
+}