@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/generation/sourceLayout.js

@@ -0,0 +1,40 @@
+/** Physical layout checks only; source interpretation and eligibility remain native responsibilities. */
+import path from 'node:path';
+import { assertLoadedSchemaInput } from '../loader/schemaInput.js';
+/** Find a finite common directory using complete parent segments, including valid names beginning with two dots.
+ * @throws Error For cross-volume inputs, cancellation or an impossible ancestor search.
+ */
+export function commonSourceDirectory(root, files, check, paths = path) {
+    let common = paths.dirname(root);
+    for (const file of files) {
+        check();
+        if (paths.parse(file).root.toLowerCase() !== paths.parse(common).root.toLowerCase())
+            throw new Error('Cross-volume source relocation requires explicit consumer source configuration');
+        for (;;) {
+            check();
+            const relative = paths.relative(common, file);
+            if (relative !== '..' && !relative.startsWith('..' + paths.sep) && !paths.isAbsolute(relative))
+                break;
+            const parent = paths.dirname(common);
+            if (parent === common)
+                throw new Error('Unable to find common source directory');
+            common = parent;
+        }
+    }
+    return common;
+}
+/** Refuse local retrieval aliases that cannot be copied as a relocatable physical tree.
+ * @remarks HTTP aliases use generated offline URI records. Local symlink aliases remain unsupported;
+ *   this scaffold does not invent filesystem links or rewrite original source bytes.
+ * @throws TypeError For unowned source input. Error For a nonrelocatable authenticated dependency or cancellation.
+ */
+export function assertCanonicalSourceLayout(input, check) {
+    assertLoadedSchemaInput(input);
+    const schemas = new Map(input.schemas.map(schema => [schema.key, schema.documentUri]));
+    for (const edge of input.edges) {
+        check();
+        if (edge.to && edge.referenceUri && new URL(edge.referenceUri).protocol === 'file:' && edge.referenceUri !== (schemas.get(edge.to) ?? edge.to)) {
+            throw new Error('Source relocation refuses import retrieval aliases; supply canonical source references or independently configured runtime inputs');
+        }
+    }
+}

package/dist/generation/writeGeneratedSource.d.ts

@@ -8,4 +8,3 @@
  * @constraints Call only after any scaffold skip/force guard.
  */
 export declare function writeGeneratedSource(filePath: string, content: string, artifact: string): void;
-//# sourceMappingURL=writeGeneratedSource.d.ts.map

package/dist/index.d.ts

@@ -4,8 +4,14 @@ export { generateGateway } from "./gateway/generateGateway.js";
 export { buildSecurity, loadSecurityConfigFile, parseSecurityConfig, SecurityConfigError, type SecurityConfig, } from "./util/securityConfig.js";
 export { generateTests } from "./test/generateTests.js";
 export { runGenerationPipeline } from "./pipeline.js";
+export type { PipelineOptions } from './pipeline.js';
+export type { CheckedComponentOptions, CheckedInventory } from './checkedPipeline.js';
+export { planCheckedComponents, formatCheckedComponentPlan, writeCheckedPlanningFile, CheckedPlanningError } from './checkedPlanning.js';
+export type { CheckedComponentPlan, ComponentPlanBlocker } from './checkedPlanning.js';
+export type { ComponentRecordProjectionSpec, ComponentRecordProjectionAssociation } from './compiler/componentRecordProjection.js';
 export { loadStreamConfigFile, parseStreamConfig, StreamConfigError, type OperationStreamMetadata, type ShapeCatalogRef, type StreamConfig, } from "./util/streamConfig.js";
 export { applyShapeCatalogs, type ApplyShapeCatalogsOptions } from "./compiler/shapeResolver.js";
+export { checkedDirectRuntimeV1, checkedComponentRuntimeV1 } from './client/checkedDirectRuntime.js';
 /**
  * Compiles a WSDL file to TypeScript client code
  *
@@ -35,4 +41,6 @@ export declare function compileWsdlToProject(input: {
     /** In-memory stream configuration. Ignored when `streamConfigFile` is set. */
     streamConfig?: import("./util/streamConfig.js").StreamConfig;
 }): Promise<void>;
-//# sourceMappingURL=index.d.ts.map
+export { assessSchemaSource, serializeAssessmentReport, parseAssessmentReport, assessmentExitCode, ASSESSMENT_VERSION, ASSESSMENT_BASIS } from './compiler/checkedAssessment.js';
+export type { ApplicationGroupsOptions, ApplicationGroupName } from './compiler/applicationGroups.js';
+export type { CheckedAssessmentReport, AssessmentObligation, AssessedOperation, AssessmentStatus } from './compiler/checkedAssessment.js';

package/dist/index.js

@@ -27,8 +27,10 @@ export { generateGateway } from "./gateway/generateGateway.js";
 export { buildSecurity, loadSecurityConfigFile, parseSecurityConfig, SecurityConfigError, } from "./util/securityConfig.js";
 export { generateTests } from "./test/generateTests.js";
 export { runGenerationPipeline } from "./pipeline.js";
+export { planCheckedComponents, formatCheckedComponentPlan, writeCheckedPlanningFile, CheckedPlanningError } from './checkedPlanning.js';
 export { loadStreamConfigFile, parseStreamConfig, StreamConfigError, } from "./util/streamConfig.js";
 export { applyShapeCatalogs } from "./compiler/shapeResolver.js";
+export { checkedDirectRuntimeV1, checkedComponentRuntimeV1 } from './client/checkedDirectRuntime.js';
 // noinspection JSUnusedGlobalSymbols
 /**
  * Compiles a WSDL file to TypeScript client code
@@ -117,3 +119,4 @@ export async function compileWsdlToProject(input) {
         generateCatalog(catalogFile, compiled);
     }
 }
+export { assessSchemaSource, serializeAssessmentReport, parseAssessmentReport, assessmentExitCode, ASSESSMENT_VERSION, ASSESSMENT_BASIS } from './compiler/checkedAssessment.js';

package/dist/loader/fetch.d.ts

@@ -33,4 +33,3 @@ export declare function fetchText(urlOrPath: string, base?: string): Promise<{
     uri: string;
     text: string;
 }>;
-//# sourceMappingURL=fetch.d.ts.map

package/dist/loader/orderedSyntax.d.ts

@@ -0,0 +1,84 @@
+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;
+/** Decode private metadata text; original bytes remain the digest and snapshot authority.
+ * @remarks ISO-8859-1 maps every byte to the same code point, including C1 controls.
+ *   HTTP charset headers are not encoding authority here. Runtime XML uses its existing policy.
+ * @throws SchemaLoadingError For malformed bytes or incompatible/unsupported declarations.
+ */
+export declare function decodeMetadataXml(bytes: Uint8Array): string;
+/** Positions are one-based lines/columns and zero-based UTF-16 offsets in decoded XML. */
+export interface OrderedSyntaxOptions {
+    /** Internal metadata boundary; payload/capsule callers retain the existing encoding policy. */
+    metadataEncoding?: boolean;
+    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;

package/dist/loader/orderedSyntax.js

@@ -0,0 +1,222 @@
+/** 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) });
+}
+const xmlEncodingDeclaration = /^<\?xml\s[^?]*encoding\s*=\s*["']([^"']+)["']/i;
+/** Decode private metadata text; original bytes remain the digest and snapshot authority.
+ * @remarks ISO-8859-1 maps every byte to the same code point, including C1 controls.
+ *   HTTP charset headers are not encoding authority here. Runtime XML uses its existing policy.
+ * @throws SchemaLoadingError For malformed bytes or incompatible/unsupported declarations.
+ */
+export function decodeMetadataXml(bytes) {
+    return decodeXml(bytes, true, true);
+}
+function decodeXml(bytes, strictBom = false, metadata = false) {
+    let encoding = bytes[0] === 0xff && bytes[1] === 0xfe ? "utf-16le"
+        : bytes[0] === 0xfe && bytes[1] === 0xff ? "utf-16be" : "utf-8";
+    try {
+        const buffer = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        // @why Sniff only an ASCII declaration, never guess Latin1 after UTF-8 failure.
+        //   A BOM fixes the encoding and must agree with the decoded declaration.
+        if (metadata && encoding === 'utf-8' && !(bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf)) {
+            const end = buffer.indexOf('>');
+            const declaration = xmlEncodingDeclaration.exec(buffer.toString('latin1', 0, end < 0 ? 0 : end + 1))?.[1].toLowerCase();
+            if (declaration === 'iso-8859-1')
+                encoding = 'iso-8859-1';
+        }
+        // TextDecoder's ISO label aliases Windows-1252; Buffer supplies actual ISO byte identity.
+        const text = encoding === 'iso-8859-1' ? buffer.toString('latin1') : new TextDecoder(encoding, { fatal: true }).decode(bytes);
+        if (strictBom && text.startsWith('\ufeff'))
+            throw new SchemaLoadingError('invalid-schema', 'Multiple XML byte order marks');
+        const declared = xmlEncodingDeclaration.exec(text)?.[1].toLowerCase();
+        const allowed = encoding === 'iso-8859-1' ? [encoding] : encoding === 'utf-8' ? ['utf-8', 'utf8'] : ['utf-16', encoding];
+        if (declared && !allowed.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 = options.metadataEncoding ? decodeMetadataXml(bytes) : 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,6 @@
+/** 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;

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,80 @@
+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[];
+    resourceAliases: ReadonlyMap<string, string>;
+    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 = {
+    /** Generated logical root for independently authorized physical snapshots; confers no I/O authority. */
+    sourceUri?: string;
+    /** Diagnostic observation only; partial documents never establish loading completeness or eligibility. */
+    onDocument?: (document: SyntaxDocument) => void;
+    signal?: AbortSignal;
+    /** Optional request accounting used by the additive assessment boundary. */
+    chargeWork?: (amount: number) => void;
+    policy: SchemaResourcePolicy;
+    limits?: Partial<LoadingLimits>;
+    offlineResources?: ReadonlyMap<string, OfflineSchemaResource>;
+    /**
+     * Explicit resource locations for XSD imports without schemaLocation.
+     * @remarks Keys are exact namespace names (including the empty namespace).
+     *   Locations resolve against the caller's working directory, never the importing
+     *   document. Explicit schemaLocation attributes take precedence. Resource policy,
+     *   digests, namespace matching and loading limits still apply; no namespace is fetched implicitly.
+     * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#composition-schemaImport
+     */
+    namespaceLocations?: ReadonlyMap<string, string>;
+};
+/** Prepare a closed input set from independently authorized physical metadata snapshots.
+ * @remarks Logical import URIs never initiate I/O here. The later native loader still checks their explicit origin/root
+ *   permissions. Missing snapshots refuse rather than falling back to network or to artifact-embedded bytes.
+ * @returns The actual physical root URI and complete offline loading configuration.
+ * @throws SchemaLoadingError For non-file physical inputs, duplicates, denied roots or unavailable files.
+ */
+export declare function prepareSchemaSnapshotFiles(root: string, files: readonly {
+    readonly uri: string;
+    readonly file: string;
+    readonly canonicalUri?: string;
+}[], options: Omit<SchemaInputOptions, 'offlineResources'>): Promise<{
+    source: string;
+    loading: SchemaInputOptions;
+}>;
+/** 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>;