semantifold 0.3.0 → 0.5.0

package/build/src/stdlib-negotiation.d.ts

@@ -0,0 +1,69 @@
+export type StdlibContractRegistry = import("./semantic/stdlib.js").StdlibContractRegistry;
+export type StdlibProviderRecord = import("./stdlib-providers.js").StdlibProviderRecord;
+export type VersionRange = import("./semantic/stdlib.js").VersionRange;
+export type StdlibNegotiationRequirement = {
+    /**
+     * - Canonical module identity.
+     */
+    module: string;
+    /**
+     * - Required canonical operations.
+     */
+    operations: string[];
+    /**
+     * - Declared version range.
+     */
+    range?: string | undefined;
+};
+export type StdlibNegotiationResult = {
+    /**
+     * - Negotiated target language.
+     */
+    target: string;
+    /**
+     * - Linked modules in identity order.
+     */
+    modules: readonly {
+        identity: string;
+        operations: string[];
+        version: string;
+    }[];
+    /**
+     * - Selected providers in identity order.
+     */
+    providers: readonly {
+        identity: string;
+        target: string;
+        module: string;
+        version: string;
+        operations: string[];
+        nativeEntries: Readonly<Record<string, string>>;
+        runtimeProfile: string;
+    }[];
+};
+/**
+ * @typedef StdlibNegotiationRequirement
+ * @property {string} module - Canonical module identity.
+ * @property {string[]} operations - Required canonical operations.
+ * @property {string | undefined} [range] - Declared version range.
+ */
+/**
+ * @typedef StdlibNegotiationResult
+ * @property {string} target - Negotiated target language.
+ * @property {readonly {identity: string, operations: string[], version: string}[]} modules - Linked modules in identity order.
+ * @property {readonly {identity: string, target: string, module: string, version: string, operations: string[], nativeEntries: Readonly<Record<string, string>>, runtimeProfile: string}[]} providers - Selected providers in identity order.
+ */
+/**
+ * Negotiates the complete transitive stdlib provider closure for one target.
+ * @param {{contracts?: StdlibContractRegistry, providers?: {providersFor(target: string, module: string, version: string): readonly StdlibProviderRecord[]}, requirements: StdlibNegotiationRequirement[], target: string}} input - Negotiation request.
+ * @returns {Readonly<StdlibNegotiationResult>} Frozen negotiation result.
+ */
+export declare function negotiateStdlibProviders({ contracts, providers, requirements, target }: {
+    contracts?: StdlibContractRegistry;
+    providers?: {
+        providersFor(target: string, module: string, version: string): readonly StdlibProviderRecord[];
+    };
+    requirements: StdlibNegotiationRequirement[];
+    target: string;
+}): Readonly<StdlibNegotiationResult>;
+//# sourceMappingURL=stdlib-negotiation.d.ts.map

package/build/src/stdlib-negotiation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdlib-negotiation.d.ts","sourceRoot":"","sources":["../../src/stdlib-negotiation.js"],"names":[],"mappings":"AAcI,YAAiE,sBAAsB,GAA7E,OAAO,sBAAsB,EAAE,sBAAsB,CAAwB;AACvF,YAAgE,oBAAoB,GAA1E,OAAO,uBAAuB,EAAE,oBAAoB,CAAsB;AACpF,YAAuD,YAAY,GAAzD,OAAO,sBAAsB,EAAE,YAAY,CAAc;AAOpE,YAAS,4BAA4B,GACrC;;;;IAAmB,MAAM,EAAd,MAAM,CACjB;;;;IAAqB,UAAU,EAApB,MAAM,EAAE,CACnB;;;;IAAgC,KAAK,AAArC,CACF,EADa,MAAM,GAAG,SAAS,CAC/B;CAAA,CAAA;AAGE,YAAS,uBAAuB,GAChC;;;;IAAmB,MAAM,EAAd,MAAM,CACjB;;;;IAAiF,OAAO,EAA7E,SAAS;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,EAAE,CAC/E;;;;IAA0L,SAAS,EAAxL,SAAS;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC,EAAE,CAC1L;CAAA,CAAA;AAZD;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,EAAC,SAA4B,EAAE,SAAkC,EAAE,YAAY,EAAE,MAAM,EAAC,EAHtH;IAAC,SAAS,CAAC,EAAE,sBAAsB,CAAC;IAAC,SAAS,CAAC,EAAE;QAAC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,oBAAoB,EAAE,CAAA;KAAC,CAAC;IAAC,YAAY,EAAE,4BAA4B,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAGzF,GAFpH,QAAQ,CAAC,uBAAuB,CAAC,CAgN7C"}

package/build/src/stdlib-negotiation.js

@@ -0,0 +1,403 @@
+// @ts-check
+import { isDenseArray } from "./array.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { compareStdlibVersions, createStdlibContractRegistry, intersectStdlibVersionRanges, parseStdlibVersion, parseStdlibVersionRange, stdlibVersionSatisfies } from "./semantic/stdlib.js";
+import { stdlibProviderRegistry } from "./stdlib-providers.js";
+/** @typedef {import("./semantic/stdlib.js").StdlibContractRegistry} StdlibContractRegistry */
+/** @typedef {import("./stdlib-providers.js").StdlibProviderRecord} StdlibProviderRecord */
+/** @typedef {import("./semantic/stdlib.js").VersionRange} VersionRange */
+/** @type {Readonly<VersionRange>} */
+const universalRange = Object.freeze({ lower: /** @type {[number, number, number]} */ (Object.freeze([0, 0, 0])), upper: null });
+const builtinContracts = createStdlibContractRegistry();
+/**
+ * @typedef StdlibNegotiationRequirement
+ * @property {string} module - Canonical module identity.
+ * @property {string[]} operations - Required canonical operations.
+ * @property {string | undefined} [range] - Declared version range.
+ */
+/**
+ * @typedef StdlibNegotiationResult
+ * @property {string} target - Negotiated target language.
+ * @property {readonly {identity: string, operations: string[], version: string}[]} modules - Linked modules in identity order.
+ * @property {readonly {identity: string, target: string, module: string, version: string, operations: string[], nativeEntries: Readonly<Record<string, string>>, runtimeProfile: string}[]} providers - Selected providers in identity order.
+ */
+/**
+ * Negotiates the complete transitive stdlib provider closure for one target.
+ * @param {{contracts?: StdlibContractRegistry, providers?: {providersFor(target: string, module: string, version: string): readonly StdlibProviderRecord[]}, requirements: StdlibNegotiationRequirement[], target: string}} input - Negotiation request.
+ * @returns {Readonly<StdlibNegotiationResult>} Frozen negotiation result.
+ */
+export function negotiateStdlibProviders({ contracts = builtinContracts, providers = stdlibProviderRegistry, requirements, target }) {
+    if (!isDenseArray(requirements))
+        invalidRequirement("Stdlib negotiation requirements must be an ordered dense array.");
+    /** @type {Map<string, VersionRange>} */
+    const ranges = new Map();
+    /** @type {Map<string, string>} */
+    const rangeKeys = new Map();
+    /** @type {Map<string, Set<string>>} */
+    const usedOperations = new Map();
+    /**
+     * Intersects one declared range into the per-module closure.
+     * @param {string} module - Canonical module identity.
+     * @param {VersionRange} range - Declared version range.
+     * @returns {boolean} Whether the combined range changed.
+     */
+    function addRange(module, range) {
+        const current = ranges.get(module) ?? universalRange;
+        const next = intersectStdlibVersionRanges(current, range);
+        if (next === null)
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_VERSION_INCOMPATIBLE",
+                language: module,
+                message: `Canonical module '${module}' has no version satisfying every declared range.`
+            });
+        const key = rangeKey(next);
+        if (rangeKeys.get(module) == key)
+            return false;
+        ranges.set(module, next);
+        rangeKeys.set(module, key);
+        return true;
+    }
+    /**
+     * Rejects a module identity absent from the contract registry.
+     * @param {string} module - Canonical module identity.
+     * @returns {void}
+     */
+    function requireModule(module) {
+        if (!contracts.modules.some(({ identity }) => identity == module)) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_MODULE_UNKNOWN",
+                language: module,
+                message: `Canonical module '${module}' is not registered.`
+            });
+        }
+    }
+    for (const requirement of requirements) {
+        if (!isPlainObject(requirement))
+            invalidRequirement("Every stdlib negotiation requirement must be a plain object.");
+        const module = /** @type {string} */ (requirement.module);
+        const operations = /** @type {unknown} */ (requirement.operations);
+        if (typeof module != "string") {
+            throw new SemantifoldDiagnostic({ code: "STDLIB_MODULE_UNKNOWN", language: String(module), message: "Canonical module identity is missing." });
+        }
+        if (!isDenseArray(operations) || !operations.every((operation) => typeof operation == "string")) {
+            invalidRequirement(`Requirement for module '${module}' declares invalid operations.`);
+        }
+        if (operations.length == 0)
+            continue;
+        requireModule(module);
+        for (const operation of /** @type {string[]} */ (operations)) {
+            const used = usedOperations.get(module) ?? new Set();
+            used.add(operation);
+            usedOperations.set(module, used);
+        }
+        if (requirement.range !== undefined) {
+            const range = parseStdlibVersionRange(requirement.range);
+            if (range === null)
+                malformedRange(String(requirement.range));
+            addRange(module, range);
+        }
+    }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const module of [...usedOperations.keys()].sort()) {
+            const contract = resolveModuleVersion(contracts, module, ranges.get(module) ?? universalRange);
+            const declared = new Map(contract.operations.map(({ dependencies, name }) => [name, dependencies]));
+            for (const dependency of contract.dependencies) {
+                requireModule(dependency.module);
+                if (addRange(dependency.module, asVersionRange(dependency.range)))
+                    changed = true;
+                if (!usedOperations.has(dependency.module)) {
+                    usedOperations.set(dependency.module, new Set());
+                    changed = true;
+                }
+            }
+            for (const operation of [... /** @type {Set<string>} */(usedOperations.get(module))].sort()) {
+                const dependencies = declared.get(operation);
+                if (dependencies === undefined)
+                    undeclaredOperation(module, operation);
+                for (const dependency of dependencies) {
+                    const { module: dependencyModule, operation: dependencyOperation, range } = dependency;
+                    requireModule(dependencyModule);
+                    if (addRange(dependencyModule, asVersionRange(range)))
+                        changed = true;
+                    const used = usedOperations.get(dependencyModule) ?? new Set();
+                    if (!used.has(dependencyOperation)) {
+                        used.add(dependencyOperation);
+                        usedOperations.set(dependencyModule, used);
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    /** @type {Map<string, StdlibProviderRecord>} */
+    const selectedProviders = new Map();
+    let stable = false;
+    while (!stable) {
+        stable = true;
+        selectedProviders.clear();
+        for (const module of [...usedOperations.keys()].sort()) {
+            const contract = resolveModuleVersion(contracts, module, ranges.get(module) ?? universalRange);
+            const candidates = providers.providersFor(target, module, contract.version);
+            if (candidates.length == 0) {
+                throw new SemantifoldDiagnostic({
+                    code: "STDLIB_PROVIDER_MISSING",
+                    language: target,
+                    message: `No registered provider serves module '${module}' version '${contract.version}'.`
+                });
+            }
+            if (candidates.length > 1) {
+                throw new SemantifoldDiagnostic({
+                    code: "STDLIB_PROVIDER_AMBIGUOUS",
+                    language: target,
+                    message: `Multiple registered providers serve module '${module}' version '${contract.version}'.`
+                });
+            }
+            const provider = /** @type {StdlibProviderRecord} */ (candidates[0]);
+            selectedProviders.set(module, provider);
+            for (const dependency of provider.dependencies) {
+                if (!contracts.modules.some(({ identity }) => identity == dependency.module)) {
+                    throw new SemantifoldDiagnostic({
+                        code: "STDLIB_PROVIDER_DEPENDENCY_MISSING",
+                        language: provider.identity,
+                        message: `Provider dependency module '${dependency.module}' is not registered.`
+                    });
+                }
+                if (addRange(dependency.module, asVersionRange(dependency.range)))
+                    stable = false;
+                if (!usedOperations.has(dependency.module)) {
+                    usedOperations.set(dependency.module, new Set());
+                    stable = false;
+                }
+            }
+        }
+    }
+    for (const module of [...usedOperations.keys()].sort()) {
+        const provider = /** @type {StdlibProviderRecord} */ (selectedProviders.get(module));
+        const provided = new Set(provider.provides[0].operations);
+        const missing = [... /** @type {Set<string>} */(usedOperations.get(module))].sort()
+            .filter((operation) => !provided.has(operation));
+        if (missing.length > 0) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_PROVIDER_MISSING",
+                language: target,
+                message: `Provider '${provider.identity}' does not provide operation${missing.length > 1 ? "s" : ""} '${missing.join("', '")}' of module '${module}'.`
+            });
+        }
+    }
+    assertAcyclic(contracts, ranges, usedOperations, selectedProviders);
+    /** @type {{identity: string, operations: string[], version: string}[]} */
+    const modules = [...usedOperations.keys()].sort().map((identity) => {
+        const contract = resolveModuleVersion(contracts, identity, ranges.get(identity) ?? universalRange);
+        const used = /** @type {Set<string>} */ (usedOperations.get(identity));
+        return {
+            identity,
+            operations: contract.operations.map(({ name }) => name).filter((name) => used.has(name)),
+            version: contract.version
+        };
+    });
+    /** @type {{identity: string, target: string, module: string, version: string, operations: string[], nativeEntries: Record<string, string>, runtimeProfile: string}[]} */
+    const providerResults = [...selectedProviders.values()].sort((left, right) => left.identity < right.identity ? -1 : left.identity > right.identity ? 1 : 0).map((provider) => {
+        const module = provider.provides[0].module;
+        const contract = resolveModuleVersion(contracts, module, ranges.get(module) ?? universalRange);
+        const used = /** @type {Set<string>} */ (usedOperations.get(module));
+        const operations = contract.operations.map(({ name }) => name).filter((name) => used.has(name));
+        return {
+            identity: provider.identity,
+            module,
+            nativeEntries: Object.fromEntries(operations.map((operation) => [
+                operation,
+                /** @type {string} */ (provider.nativeEntries[operation])
+            ])),
+            operations,
+            runtimeProfile: provider.runtimeProfile,
+            target: provider.target,
+            version: provider.provides[0].version
+        };
+    });
+    return deepFreeze(/** @type {StdlibNegotiationResult} */ ({ modules, providers: providerResults, target }));
+}
+/**
+ * Resolves the highest registered contract version satisfying one combined range.
+ * @param {StdlibContractRegistry} contracts - Canonical contract registry.
+ * @param {string} module - Canonical module identity.
+ * @param {VersionRange} range - Combined half-open range.
+ * @returns {import("./semantic/stdlib.js").StdlibContract} Exact-version contract.
+ */
+function resolveModuleVersion(contracts, module, range) {
+    const listed = contracts.modules.find(({ identity }) => identity == module);
+    if (!listed) {
+        throw new SemantifoldDiagnostic({ code: "STDLIB_MODULE_UNKNOWN", language: module, message: `Canonical module '${module}' is not registered.` });
+    }
+    /** @type {[number, number, number] | null} */
+    let resolved = null;
+    for (const version of listed.versions) {
+        const tuple = /** @type {[number, number, number]} */ (parseStdlibVersion(version));
+        if (stdlibVersionSatisfies(tuple, range) && (resolved === null || compareStdlibVersions(tuple, resolved) > 0)) {
+            resolved = tuple;
+        }
+    }
+    if (resolved === null) {
+        throw new SemantifoldDiagnostic({
+            code: "STDLIB_VERSION_INCOMPATIBLE",
+            language: module,
+            message: `Canonical module '${module}' has no registered version satisfying the combined range.`
+        });
+    }
+    return contracts.resolveModule(module, `${resolved[0]}.${resolved[1]}.${resolved[2]}`);
+}
+/**
+ * Fails deterministically when canonical operation dependencies or selected provider
+ * module dependencies cycle.
+ * @param {StdlibContractRegistry} contracts - Canonical contract registry.
+ * @param {Map<string, VersionRange>} ranges - Combined ranges per module.
+ * @param {Map<string, Set<string>>} usedOperations - Used operations per module.
+ * @param {Map<string, StdlibProviderRecord>} selectedProviders - Selected provider per module.
+ * @returns {void}
+ */
+function assertAcyclic(contracts, ranges, usedOperations, selectedProviders) {
+    /** @type {Map<string, string[]>} */
+    const edges = new Map();
+    for (const module of [...usedOperations.keys()].sort()) {
+        const contract = resolveModuleVersion(contracts, module, ranges.get(module) ?? universalRange);
+        const declared = new Map(contract.operations.map(({ dependencies, name }) => [name, dependencies]));
+        const used = /** @type {Set<string>} */ (usedOperations.get(module));
+        for (const operation of [...used].sort()) {
+            const nodeKey = `${module}\u0000${operation}`;
+            const targets = /** @type {string[]} */ (edges.get(nodeKey) ?? []);
+            for (const dependency of /** @type {{module: string, operation: string}[]} */ (declared.get(operation))) {
+                targets.push(`${dependency.module}\u0000${dependency.operation}`);
+            }
+            edges.set(nodeKey, targets.sort());
+        }
+        const moduleNodeKey = `${module}\u0000\u0000`;
+        const moduleTargets = /** @type {string[]} */ (edges.get(moduleNodeKey) ?? []);
+        for (const dependency of contract.dependencies)
+            moduleTargets.push(`${dependency.module}\u0000\u0000`);
+        edges.set(moduleNodeKey, moduleTargets.sort());
+    }
+    for (const module of [...selectedProviders.keys()].sort()) {
+        const provider = /** @type {StdlibProviderRecord} */ (selectedProviders.get(module));
+        const nodeKey = `${module}\u0000\u0000`;
+        const targets = /** @type {string[]} */ (edges.get(nodeKey) ?? []);
+        for (const dependency of provider.dependencies) {
+            targets.push(`${dependency.module}\u0000\u0000`);
+        }
+        edges.set(nodeKey, targets.sort());
+    }
+    /** @type {Map<string, number>} */
+    const colors = new Map();
+    /**
+     * Walks the dependency edges in deterministic order, rejecting cycles.
+     * @param {string} nodeKey - Node key.
+     * @returns {void}
+     */
+    function visit(nodeKey) {
+        colors.set(nodeKey, 1);
+        for (const target of /** @type {string[]} */ (edges.get(nodeKey) ?? [])) {
+            const color = colors.get(target) ?? 0;
+            if (color == 1)
+                throw new SemantifoldDiagnostic({
+                    code: "STDLIB_PROVIDER_CYCLE",
+                    language: target.split("\u0000")[0],
+                    message: "Canonical stdlib dependencies form a cycle."
+                });
+            if (color == 0)
+                visit(target);
+        }
+        colors.set(nodeKey, 2);
+    }
+    for (const nodeKey of [...edges.keys()].sort()) {
+        if ((colors.get(nodeKey) ?? 0) == 0)
+            visit(nodeKey);
+    }
+}
+/**
+ * Normalizes a declared dependency range, accepting canonical strings or parsed ranges.
+ * @param {unknown} value - Candidate range.
+ * @returns {VersionRange} Half-open range.
+ */
+function asVersionRange(value) {
+    if (typeof value == "string") {
+        const parsed = parseStdlibVersionRange(value);
+        if (parsed === null)
+            malformedRange(value);
+        return parsed;
+    }
+    if (isPlainObject(value) && Array.isArray(value.lower) && value.lower.length == 3 &&
+        value.lower.every((part) => Number.isInteger(part)) &&
+        (value.upper === null || (Array.isArray(value.upper) && value.upper.length == 3 &&
+            value.upper.every((part) => Number.isInteger(part))))) {
+        return { lower: /** @type {[number, number, number]} */ (value.lower), upper: value.upper === null ? null : /** @type {[number, number, number]} */ (value.upper) };
+    }
+    return malformedRange(String(value));
+}
+/**
+ * Encodes one half-open range deterministically.
+ * @param {VersionRange} range - Half-open range.
+ * @returns {string} Stable key.
+ */
+function rangeKey(range) {
+    return `${range.lower.join(".")}..${range.upper === null ? "" : range.upper.join(".")}`;
+}
+/**
+ * Throws a malformed-version-range diagnostic.
+ * @param {string} range - Candidate range.
+ * @returns {never} Always throws.
+ */
+function malformedRange(range) {
+    throw new SemantifoldDiagnostic({
+        code: "STDLIB_VERSION_MALFORMED",
+        language: "stdlib",
+        message: `Stdlib version range '${range}' is not canonical.`
+    });
+}
+/**
+ * Throws an undeclared-operation diagnostic.
+ * @param {string} module - Canonical module identity.
+ * @param {string} operation - Missing operation.
+ * @returns {never} Always throws.
+ */
+function undeclaredOperation(module, operation) {
+    throw new SemantifoldDiagnostic({
+        code: "STDLIB_OPERATION_UNDECLARED",
+        language: module,
+        message: `Operation '${operation}' is not declared by canonical module '${module}'.`
+    });
+}
+/**
+ * Throws a requirement-shape diagnostic.
+ * @param {string} message - Failure detail.
+ * @returns {never} Always throws.
+ */
+function invalidRequirement(message) {
+    throw new SemantifoldDiagnostic({ code: "STDLIB_CONTRACT_INVALID", language: "stdlib", message });
+}
+/**
+ * Checks for an ordinary string-keyed object.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is Record<string, unknown>} Whether the value is a plain object.
+ */
+function isPlainObject(value) {
+    if (typeof value != "object" || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * Deep-freezes a detached value.
+ * @template T
+ * @param {T} value - Detached value.
+ * @returns {Readonly<T>} Frozen value.
+ */
+function deepFreeze(value) {
+    if (typeof value != "object" || value === null || Object.isFrozen(value))
+        return /** @type {Readonly<T>} */ (value);
+    Object.freeze(value);
+    for (const property of Object.getOwnPropertyNames(value)) {
+        deepFreeze(/** @type {unknown} */ (/** @type {Record<string, unknown>} */ (value)[property]));
+    }
+    return /** @type {Readonly<T>} */ (value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stdlib-negotiation.js","sourceRoot":"","sources":["../../src/stdlib-negotiation.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {isDenseArray} from \"./array.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {\n  compareStdlibVersions,\n  createStdlibContractRegistry,\n  intersectStdlibVersionRanges,\n  parseStdlibVersion,\n  parseStdlibVersionRange,\n  stdlibVersionSatisfies\n} from \"./semantic/stdlib.js\"\nimport {stdlibProviderRegistry} from \"./stdlib-providers.js\"\n\n/** @typedef {import(\"./semantic/stdlib.js\").StdlibContractRegistry} StdlibContractRegistry */\n/** @typedef {import(\"./stdlib-providers.js\").StdlibProviderRecord} StdlibProviderRecord */\n/** @typedef {import(\"./semantic/stdlib.js\").VersionRange} VersionRange */\n\n/** @type {Readonly<VersionRange>} */\nconst universalRange = Object.freeze({lower: /** @type {[number, number, number]} */ (Object.freeze([0, 0, 0])), upper: null})\nconst builtinContracts = createStdlibContractRegistry()\n\n/**\n * @typedef StdlibNegotiationRequirement\n * @property {string} module - Canonical module identity.\n * @property {string[]} operations - Required canonical operations.\n * @property {string | undefined} [range] - Declared version range.\n */\n\n/**\n * @typedef StdlibNegotiationResult\n * @property {string} target - Negotiated target language.\n * @property {readonly {identity: string, operations: string[], version: string}[]} modules - Linked modules in identity order.\n * @property {readonly {identity: string, target: string, module: string, version: string, operations: string[], nativeEntries: Readonly<Record<string, string>>, runtimeProfile: string}[]} providers - Selected providers in identity order.\n */\n\n/**\n * Negotiates the complete transitive stdlib provider closure for one target.\n * @param {{contracts?: StdlibContractRegistry, providers?: {providersFor(target: string, module: string, version: string): readonly StdlibProviderRecord[]}, requirements: StdlibNegotiationRequirement[], target: string}} input - Negotiation request.\n * @returns {Readonly<StdlibNegotiationResult>} Frozen negotiation result.\n */\nexport function negotiateStdlibProviders({contracts = builtinContracts, providers = stdlibProviderRegistry, requirements, target}) {\n  if (!isDenseArray(requirements)) invalidRequirement(\"Stdlib negotiation requirements must be an ordered dense array.\")\n  /** @type {Map<string, VersionRange>} */\n  const ranges = new Map()\n  /** @type {Map<string, string>} */\n  const rangeKeys = new Map()\n  /** @type {Map<string, Set<string>>} */\n  const usedOperations = new Map()\n\n  /**\n   * Intersects one declared range into the per-module closure.\n   * @param {string} module - Canonical module identity.\n   * @param {VersionRange} range - Declared version range.\n   * @returns {boolean} Whether the combined range changed.\n   */\n  function addRange(module, range) {\n    const current = ranges.get(module) ?? universalRange\n    const next = intersectStdlibVersionRanges(current, range)\n\n    if (next === null) throw new SemantifoldDiagnostic({\n      code: \"STDLIB_VERSION_INCOMPATIBLE\",\n      language: module,\n      message: `Canonical module '${module}' has no version satisfying every declared range.`\n    })\n    const key = rangeKey(next)\n\n    if (rangeKeys.get(module) == key) return false\n    ranges.set(module, next)\n    rangeKeys.set(module, key)\n    return true\n  }\n\n  /**\n   * Rejects a module identity absent from the contract registry.\n   * @param {string} module - Canonical module identity.\n   * @returns {void}\n   */\n  function requireModule(module) {\n    if (!contracts.modules.some(({identity}) => identity == module)) {\n      throw new SemantifoldDiagnostic({\n        code: \"STDLIB_MODULE_UNKNOWN\",\n        language: module,\n        message: `Canonical module '${module}' is not registered.`\n      })\n    }\n  }\n\n  for (const requirement of requirements) {\n    if (!isPlainObject(requirement)) invalidRequirement(\"Every stdlib negotiation requirement must be a plain object.\")\n    const module = /** @type {string} */ (requirement.module)\n    const operations = /** @type {unknown} */ (requirement.operations)\n\n    if (typeof module != \"string\") {\n      throw new SemantifoldDiagnostic({code: \"STDLIB_MODULE_UNKNOWN\", language: String(module), message: \"Canonical module identity is missing.\"})\n    }\n    if (!isDenseArray(operations) || !operations.every((operation) => typeof operation == \"string\")) {\n      invalidRequirement(`Requirement for module '${module}' declares invalid operations.`)\n    }\n    if (operations.length == 0) continue\n    requireModule(module)\n    for (const operation of /** @type {string[]} */ (operations)) {\n      const used = usedOperations.get(module) ?? new Set()\n\n      used.add(operation)\n      usedOperations.set(module, used)\n    }\n    if (requirement.range !== undefined) {\n      const range = parseStdlibVersionRange(requirement.range)\n\n      if (range === null) malformedRange(String(requirement.range))\n      addRange(module, range)\n    }\n  }\n\n  let changed = true\n\n  while (changed) {\n    changed = false\n\n    for (const module of [...usedOperations.keys()].sort()) {\n      const contract = resolveModuleVersion(contracts, module, ranges.get(module) ?? universalRange)\n      const declared = new Map(contract.operations.map(({dependencies, name}) => [name, dependencies]))\n\n      for (const dependency of contract.dependencies) {\n        requireModule(dependency.module)\n        if (addRange(dependency.module, asVersionRange(dependency.range))) changed = true\n        if (!usedOperations.has(dependency.module)) {\n          usedOperations.set(dependency.module, new Set())\n          changed = true\n        }\n      }\n\n      for (const operation of [.../** @type {Set<string>} */ (usedOperations.get(module))].sort()) {\n        const dependencies = declared.get(operation)\n\n        if (dependencies === undefined) undeclaredOperation(module, operation)\n        for (const dependency of dependencies) {\n          const {module: dependencyModule, operation: dependencyOperation, range} = dependency\n\n          requireModule(dependencyModule)\n          if (addRange(dependencyModule, asVersionRange(range))) changed = true\n          const used = usedOperations.get(dependencyModule) ?? new Set()\n\n          if (!used.has(dependencyOperation)) {\n            used.add(dependencyOperation)\n            usedOperations.set(dependencyModule, used)\n            changed = true\n          }\n        }\n      }\n    }\n  }\n\n  /** @type {Map<string, StdlibProviderRecord>} */\n  const selectedProviders = new Map()\n  let stable = false\n\n  while (!stable) {\n    stable = true\n    selectedProviders.clear()\n\n    for (const module of [...usedOperations.keys()].sort()) {\n      const contract = resolveModuleVersion(contracts, module, ranges.get(module) ?? universalRange)\n      const candidates = providers.providersFor(target, module, contract.version)\n\n      if (candidates.length == 0) {\n        throw new SemantifoldDiagnostic({\n          code: \"STDLIB_PROVIDER_MISSING\",\n          language: target,\n          message: `No registered provider serves module '${module}' version '${contract.version}'.`\n        })\n      }\n      if (candidates.length > 1) {\n        throw new SemantifoldDiagnostic({\n          code: \"STDLIB_PROVIDER_AMBIGUOUS\",\n          language: target,\n          message: `Multiple registered providers serve module '${module}' version '${contract.version}'.`\n        })\n      }\n      const provider = /** @type {StdlibProviderRecord} */ (candidates[0])\n\n      selectedProviders.set(module, provider)\n      for (const dependency of provider.dependencies) {\n        if (!contracts.modules.some(({identity}) => identity == dependency.module)) {\n          throw new SemantifoldDiagnostic({\n            code: \"STDLIB_PROVIDER_DEPENDENCY_MISSING\",\n            language: provider.identity,\n            message: `Provider dependency module '${dependency.module}' is not registered.`\n          })\n        }\n        if (addRange(dependency.module, asVersionRange(dependency.range))) stable = false\n        if (!usedOperations.has(dependency.module)) {\n          usedOperations.set(dependency.module, new Set())\n          stable = false\n        }\n      }\n    }\n  }\n  for (const module of [...usedOperations.keys()].sort()) {\n    const provider = /** @type {StdlibProviderRecord} */ (selectedProviders.get(module))\n    const provided = new Set(provider.provides[0].operations)\n    const missing = [.../** @type {Set<string>} */ (usedOperations.get(module))].sort()\n      .filter((operation) => !provided.has(operation))\n\n    if (missing.length > 0) {\n      throw new SemantifoldDiagnostic({\n        code: \"STDLIB_PROVIDER_MISSING\",\n        language: target,\n        message: `Provider '${provider.identity}' does not provide operation${missing.length > 1 ? \"s\" : \"\"} '${missing.join(\"', '\")}' of module '${module}'.`\n      })\n    }\n  }\n  assertAcyclic(contracts, ranges, usedOperations, selectedProviders)\n  /** @type {{identity: string, operations: string[], version: string}[]} */\n  const modules = [...usedOperations.keys()].sort().map((identity) => {\n    const contract = resolveModuleVersion(contracts, identity, ranges.get(identity) ?? universalRange)\n    const used = /** @type {Set<string>} */ (usedOperations.get(identity))\n\n    return {\n      identity,\n      operations: contract.operations.map(({name}) => name).filter((name) => used.has(name)),\n      version: contract.version\n    }\n  })\n  /** @type {{identity: string, target: string, module: string, version: string, operations: string[], nativeEntries: Record<string, string>, runtimeProfile: string}[]} */\n  const providerResults = [...selectedProviders.values()].sort((left, right) =>\n    left.identity < right.identity ? -1 : left.identity > right.identity ? 1 : 0).map((provider) => {\n    const module = provider.provides[0].module\n    const contract = resolveModuleVersion(contracts, module, ranges.get(module) ?? universalRange)\n    const used = /** @type {Set<string>} */ (usedOperations.get(module))\n    const operations = contract.operations.map(({name}) => name).filter((name) => used.has(name))\n\n    return {\n      identity: provider.identity,\n      module,\n      nativeEntries: Object.fromEntries(operations.map((operation) => [\n        operation,\n        /** @type {string} */ (provider.nativeEntries[operation])\n      ])),\n      operations,\n      runtimeProfile: provider.runtimeProfile,\n      target: provider.target,\n      version: provider.provides[0].version\n    }\n  })\n  return deepFreeze(/** @type {StdlibNegotiationResult} */ ({modules, providers: providerResults, target}))\n}\n\n/**\n * Resolves the highest registered contract version satisfying one combined range.\n * @param {StdlibContractRegistry} contracts - Canonical contract registry.\n * @param {string} module - Canonical module identity.\n * @param {VersionRange} range - Combined half-open range.\n * @returns {import(\"./semantic/stdlib.js\").StdlibContract} Exact-version contract.\n */\nfunction resolveModuleVersion(contracts, module, range) {\n  const listed = contracts.modules.find(({identity}) => identity == module)\n\n  if (!listed) {\n    throw new SemantifoldDiagnostic({code: \"STDLIB_MODULE_UNKNOWN\", language: module, message: `Canonical module '${module}' is not registered.`})\n  }\n  /** @type {[number, number, number] | null} */\n  let resolved = null\n\n  for (const version of listed.versions) {\n    const tuple = /** @type {[number, number, number]} */ (parseStdlibVersion(version))\n\n    if (stdlibVersionSatisfies(tuple, range) && (resolved === null || compareStdlibVersions(tuple, resolved) > 0)) {\n      resolved = tuple\n    }\n  }\n  if (resolved === null) {\n    throw new SemantifoldDiagnostic({\n      code: \"STDLIB_VERSION_INCOMPATIBLE\",\n      language: module,\n      message: `Canonical module '${module}' has no registered version satisfying the combined range.`\n    })\n  }\n  return contracts.resolveModule(module, `${resolved[0]}.${resolved[1]}.${resolved[2]}`)\n}\n\n/**\n * Fails deterministically when canonical operation dependencies or selected provider\n * module dependencies cycle.\n * @param {StdlibContractRegistry} contracts - Canonical contract registry.\n * @param {Map<string, VersionRange>} ranges - Combined ranges per module.\n * @param {Map<string, Set<string>>} usedOperations - Used operations per module.\n * @param {Map<string, StdlibProviderRecord>} selectedProviders - Selected provider per module.\n * @returns {void}\n */\nfunction assertAcyclic(contracts, ranges, usedOperations, selectedProviders) {\n  /** @type {Map<string, string[]>} */\n  const edges = new Map()\n\n  for (const module of [...usedOperations.keys()].sort()) {\n    const contract = resolveModuleVersion(contracts, module, ranges.get(module) ?? universalRange)\n    const declared = new Map(contract.operations.map(({dependencies, name}) => [name, dependencies]))\n    const used = /** @type {Set<string>} */ (usedOperations.get(module))\n\n    for (const operation of [...used].sort()) {\n      const nodeKey = `${module}\\u0000${operation}`\n      const targets = /** @type {string[]} */ (edges.get(nodeKey) ?? [])\n\n      for (const dependency of /** @type {{module: string, operation: string}[]} */ (declared.get(operation))) {\n        targets.push(`${dependency.module}\\u0000${dependency.operation}`)\n      }\n      edges.set(nodeKey, targets.sort())\n    }\n    const moduleNodeKey = `${module}\\u0000\\u0000`\n    const moduleTargets = /** @type {string[]} */ (edges.get(moduleNodeKey) ?? [])\n\n    for (const dependency of contract.dependencies) moduleTargets.push(`${dependency.module}\\u0000\\u0000`)\n    edges.set(moduleNodeKey, moduleTargets.sort())\n  }\n  for (const module of [...selectedProviders.keys()].sort()) {\n    const provider = /** @type {StdlibProviderRecord} */ (selectedProviders.get(module))\n    const nodeKey = `${module}\\u0000\\u0000`\n    const targets = /** @type {string[]} */ (edges.get(nodeKey) ?? [])\n\n    for (const dependency of provider.dependencies) {\n      targets.push(`${dependency.module}\\u0000\\u0000`)\n    }\n    edges.set(nodeKey, targets.sort())\n  }\n  /** @type {Map<string, number>} */\n  const colors = new Map()\n  /**\n   * Walks the dependency edges in deterministic order, rejecting cycles.\n   * @param {string} nodeKey - Node key.\n   * @returns {void}\n   */\n  function visit(nodeKey) {\n    colors.set(nodeKey, 1)\n\n    for (const target of /** @type {string[]} */ (edges.get(nodeKey) ?? [])) {\n      const color = colors.get(target) ?? 0\n\n      if (color == 1) throw new SemantifoldDiagnostic({\n        code: \"STDLIB_PROVIDER_CYCLE\",\n        language: target.split(\"\\u0000\")[0],\n        message: \"Canonical stdlib dependencies form a cycle.\"\n      })\n      if (color == 0) visit(target)\n    }\n    colors.set(nodeKey, 2)\n  }\n\n  for (const nodeKey of [...edges.keys()].sort()) {\n    if ((colors.get(nodeKey) ?? 0) == 0) visit(nodeKey)\n  }\n}\n\n/**\n * Normalizes a declared dependency range, accepting canonical strings or parsed ranges.\n * @param {unknown} value - Candidate range.\n * @returns {VersionRange} Half-open range.\n */\nfunction asVersionRange(value) {\n  if (typeof value == \"string\") {\n    const parsed = parseStdlibVersionRange(value)\n\n    if (parsed === null) malformedRange(value)\n    return parsed\n  }\n  if (isPlainObject(value) && Array.isArray(value.lower) && value.lower.length == 3 &&\n    value.lower.every((part) => Number.isInteger(part)) &&\n    (value.upper === null || (Array.isArray(value.upper) && value.upper.length == 3 &&\n      value.upper.every((part) => Number.isInteger(part))))) {\n    return {lower: /** @type {[number, number, number]} */ (value.lower), upper: value.upper === null ? null : /** @type {[number, number, number]} */ (value.upper)}\n  }\n  return malformedRange(String(value))\n}\n\n/**\n * Encodes one half-open range deterministically.\n * @param {VersionRange} range - Half-open range.\n * @returns {string} Stable key.\n */\nfunction rangeKey(range) {\n  return `${range.lower.join(\".\")}..${range.upper === null ? \"\" : range.upper.join(\".\")}`\n}\n\n/**\n * Throws a malformed-version-range diagnostic.\n * @param {string} range - Candidate range.\n * @returns {never} Always throws.\n */\nfunction malformedRange(range) {\n  throw new SemantifoldDiagnostic({\n    code: \"STDLIB_VERSION_MALFORMED\",\n    language: \"stdlib\",\n    message: `Stdlib version range '${range}' is not canonical.`\n  })\n}\n\n/**\n * Throws an undeclared-operation diagnostic.\n * @param {string} module - Canonical module identity.\n * @param {string} operation - Missing operation.\n * @returns {never} Always throws.\n */\nfunction undeclaredOperation(module, operation) {\n  throw new SemantifoldDiagnostic({\n    code: \"STDLIB_OPERATION_UNDECLARED\",\n    language: module,\n    message: `Operation '${operation}' is not declared by canonical module '${module}'.`\n  })\n}\n\n/**\n * Throws a requirement-shape diagnostic.\n * @param {string} message - Failure detail.\n * @returns {never} Always throws.\n */\nfunction invalidRequirement(message) {\n  throw new SemantifoldDiagnostic({code: \"STDLIB_CONTRACT_INVALID\", language: \"stdlib\", message})\n}\n\n/**\n * Checks for an ordinary string-keyed object.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is a plain object.\n */\nfunction isPlainObject(value) {\n  if (typeof value != \"object\" || value === null) return false\n  const prototype = Object.getPrototypeOf(value)\n\n  return prototype === Object.prototype || prototype === null\n}\n\n/**\n * Deep-freezes a detached value.\n * @template T\n * @param {T} value - Detached value.\n * @returns {Readonly<T>} Frozen value.\n */\nfunction deepFreeze(value) {\n  if (typeof value != \"object\" || value === null || Object.isFrozen(value)) return /** @type {Readonly<T>} */ (value)\n  Object.freeze(value)\n\n  for (const property of Object.getOwnPropertyNames(value)) {\n    deepFreeze(/** @type {unknown} */ ((/** @type {Record<string, unknown>} */ (value))[property]))\n  }\n  return /** @type {Readonly<T>} */ (value)\n}\n"]}

package/build/src/stdlib-providers.d.ts

@@ -0,0 +1,72 @@
+export { protectedEntryName } from "./semantic/stdlib.js";
+export type StdlibProviderRecord = {
+    /**
+     * - Generated provider artifact declaration.
+     */
+    artifact: {
+        mediaType: string;
+        path: string;
+    };
+    /**
+     * - Canonical module dependencies with declared ranges.
+     */
+    dependencies: readonly {
+        module: string;
+        range: string;
+    }[];
+    /**
+     * - Stable provider identity rooted at the target.
+     */
+    identity: string;
+    /**
+     * - Operation to protected native entry name.
+     */
+    nativeEntries: Readonly<Record<string, string>>;
+    /**
+     * - Exactly one provided canonical module.
+     */
+    provides: readonly {
+        module: string;
+        operations: string[];
+        version: string;
+    }[];
+    /**
+     * - Closed target runtime/provider profile.
+     */
+    runtimeProfile: string;
+    /**
+     * - Adopted target language identity.
+     */
+    target: string;
+};
+export type StdlibProviderRegistry = {
+    /**
+     * - Registered provider records in stable order.
+     */
+    records: readonly StdlibProviderRecord[];
+    /**
+     * - Exact provider lookup.
+     */
+    providersFor: {
+        (target: string, module: string, version: string): readonly StdlibProviderRecord[];
+    };
+};
+/**
+ * Creates the versioned target host stdlib provider registry.
+ * @param {unknown} records - Ordered provider records; built-in providers by default.
+ * @returns {Readonly<StdlibProviderRegistry>} Frozen registry.
+ */
+export declare function createStdlibProviderRegistry(records?: unknown): Readonly<StdlibProviderRegistry>;
+/**
+ * Lists the built-in target host providers for the probe contract in stable target order.
+ * @returns {readonly StdlibProviderRecord[]} Frozen provider records.
+ */
+export declare function listStdlibProviders(): readonly StdlibProviderRecord[];
+/**
+ * Authoritative built-in provider lookup keyed by exact target, module, and version.
+ * @type {{providersFor(target: string, module: string, version: string): readonly StdlibProviderRecord[]}}
+ */
+export declare const stdlibProviderRegistry: {
+    providersFor(target: string, module: string, version: string): readonly StdlibProviderRecord[];
+};
+//# sourceMappingURL=stdlib-providers.d.ts.map

package/build/src/stdlib-providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdlib-providers.d.ts","sourceRoot":"","sources":["../../src/stdlib-providers.js"],"names":[],"mappings":"AAcA,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAA;AAGpD,YAAS,oBAAoB,GAC7B;;;;IAA8C,QAAQ,EAA3C;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAC5C;;;;IAAuD,YAAY,EAAxD,SAAS;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,EAAE,CACrD;;;;IAAmB,QAAQ,EAAhB,MAAM,CACjB;;;;IAA6C,aAAa,EAA/C,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAC3C;;;;IAA+E,QAAQ,EAA5E,SAAS;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,EAAE,CAC7E;;;;IAAmB,cAAc,EAAtB,MAAM,CACjB;;;;IAAmB,MAAM,EAAd,MAAM,CACnB;CAAA,CAAA;AAGE,YAAS,sBAAsB,GAC/B;;;;IAA4C,OAAO,EAAxC,SAAS,oBAAoB,EAAE,CAC1C;;;;IAAiG,YAAY,EAAlG;QAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,oBAAoB,EAAE,CAAA;KAAC,CACjG;CAAA,CAAA;AA8BD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,GAHzC,OAGoE,GAFlE,QAAQ,CAAC,sBAAsB,CAAC,CA2B5C;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAFtB,SAAS,oBAAoB,EAAE,CAI3C;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAFzB;IAAC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,oBAAoB,EAAE,CAAA;CAMxG,CAAA"}