semantifold 0.3.0 → 0.5.0

package/build/src/stdlib-providers.js

@@ -0,0 +1,339 @@
+// @ts-check
+import { isDenseArray } from "./array.js";
+import { isSafeArtifactPath } from "./artifact-path.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { languageRegistry } from "./language-registry.js";
+import { listStdlibModules, parseStdlibVersion, parseStdlibVersionRange, protectedEntryName, resolveStdlibModule } from "./semantic/stdlib.js";
+export { protectedEntryName } from "./semantic/stdlib.js";
+/**
+ * @typedef StdlibProviderRecord
+ * @property {{mediaType: string, path: string}} artifact - Generated provider artifact declaration.
+ * @property {readonly {module: string, range: string}[]} dependencies - Canonical module dependencies with declared ranges.
+ * @property {string} identity - Stable provider identity rooted at the target.
+ * @property {Readonly<Record<string, string>>} nativeEntries - Operation to protected native entry name.
+ * @property {readonly {module: string, operations: string[], version: string}[]} provides - Exactly one provided canonical module.
+ * @property {string} runtimeProfile - Closed target runtime/provider profile.
+ * @property {string} target - Adopted target language identity.
+ */
+/**
+ * @typedef StdlibProviderRegistry
+ * @property {readonly StdlibProviderRecord[]} records - Registered provider records in stable order.
+ * @property {{(target: string, module: string, version: string): readonly StdlibProviderRecord[]}} providersFor - Exact provider lookup.
+ */
+const providerIdentityPrefix = "semantifold.provider.";
+/** @type {Readonly<Record<string, string>>} */
+const targetExtensions = Object.freeze({
+    javascript: "js",
+    java: "java",
+    php: "php",
+    ruby: "rb",
+    typescript: "ts"
+});
+const builtinProviderTargets = Object.freeze(["php", "ruby", "javascript", "typescript", "java"]);
+const probeIdentity = "semantifold.task034.resource-probe";
+const probeOperations = Object.freeze(["probeEffect", "probeAcquire", "probeRead", "probeClose", "probeTrace"]);
+const recordKeys = Object.freeze(["artifact", "dependencies", "identity", "nativeEntries", "provides", "runtimeProfile", "target"]);
+const task037ProviderModules = Object.freeze([
+    Object.freeze({ dependencies: [], identity: "semantifold.resource", operations: ["v1_close"] }),
+    Object.freeze({ dependencies: [{ module: "semantifold.resource", range: "1" }], identity: "semantifold.socket-client", operations: ["v1_connect"] }),
+    Object.freeze({ dependencies: [{ module: "semantifold.resource", range: "1" }], identity: "semantifold.text-stream", operations: ["v1_read_line"] }),
+    Object.freeze({ dependencies: [], identity: "semantifold.output", operations: ["v1_write_line"] })
+]);
+/** @type {Readonly<Record<string, string>>} */
+const legacyRuntimeProfiles = Object.freeze({
+    javascript: "node24-core-v1",
+    java: "java17-core-v1",
+    php: "php82-core-v1",
+    ruby: "ruby3-core-v1",
+    typescript: "node24-typescript7-core-v1"
+});
+/**
+ * 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 function createStdlibProviderRegistry(records = builtinProviderRecords()) {
+    if (!isDenseArray(records))
+        invalidProvider("Provider records must be an ordered dense array.");
+    /** @type {StdlibProviderRecord[]} */
+    const validated = [];
+    /** @type {Set<string>} */
+    const identities = new Set();
+    for (const candidate of records) {
+        const record = validateProviderRecord(candidate);
+        if (identities.has(record.identity))
+            invalidProvider(`Duplicate stdlib provider identity '${record.identity}'.`);
+        identities.add(record.identity);
+        validated.push(record);
+    }
+    const frozenRecords = deepFreeze(validated);
+    return Object.freeze(/** @type {Readonly<StdlibProviderRegistry>} */ ({
+        records: frozenRecords,
+        providersFor(target, module, version) {
+            if (typeof target != "string" || typeof module != "string" || typeof version != "string")
+                return Object.freeze([]);
+            return Object.freeze(frozenRecords.filter((record) => record.target == target && record.provides[0].module == module && record.provides[0].version == version));
+        }
+    }));
+}
+/**
+ * Lists the built-in target host providers for the probe contract in stable target order.
+ * @returns {readonly StdlibProviderRecord[]} Frozen provider records.
+ */
+export function listStdlibProviders() {
+    return builtinProviderRegistry().records;
+}
+/**
+ * Authoritative built-in provider lookup keyed by exact target, module, and version.
+ * @type {{providersFor(target: string, module: string, version: string): readonly StdlibProviderRecord[]}}
+ */
+export const stdlibProviderRegistry = {
+    providersFor(target, module, version) {
+        return builtinProviderRegistry().providersFor(target, module, version);
+    }
+};
+/**
+ * Validates one provider record against the target roles and canonical contract registry.
+ * @param {unknown} candidate - Candidate record.
+ * @returns {StdlibProviderRecord} Detached frozen record.
+ */
+function validateProviderRecord(candidate) {
+    if (!isPlainObject(candidate))
+        invalidProvider("Every stdlib provider record must be a plain object.");
+    if (Object.keys(candidate).sort().join(",") != recordKeys.join(",")) {
+        invalidProvider("Every stdlib provider record declares the exact provider record fields.");
+    }
+    const target = /** @type {string} */ (candidate.target);
+    if (typeof target != "string" || !providerTargetRegistered(target)) {
+        invalidProvider(`Stdlib provider target '${String(target)}' is not an adopted target host provider.`);
+    }
+    const identity = /** @type {string} */ (candidate.identity);
+    const identityPrefix = providerIdentityPrefix + target + ".";
+    if (typeof identity != "string" || !identity.startsWith(identityPrefix) || identity.length == identityPrefix.length) {
+        invalidProvider(`Stdlib provider identity '${String(identity)}' must be rooted at '${identityPrefix}'.`);
+    }
+    const provides = /** @type {unknown} */ (candidate.provides);
+    if (!isDenseArray(provides) || provides.length != 1)
+        invalidProvider("Every stdlib provider provides exactly one canonical module.");
+    const provision = /** @type {unknown} */ (provides[0]);
+    if (!isPlainObject(provision) || Object.keys(provision).sort().join(",") != "module,operations,version") {
+        invalidProvider("Every stdlib provider provision declares the exact provision fields.");
+    }
+    const module = /** @type {string} */ (provision.module);
+    if (typeof module != "string" || !/^[a-z][a-z0-9.-]*$/u.test(module)) {
+        invalidProvider(`Stdlib provider module '${String(module)}' is not a canonical identity.`);
+    }
+    const version = /** @type {string} */ (provision.version);
+    if (parseStdlibVersion(version) === null) {
+        throw new SemantifoldDiagnostic({
+            code: "STDLIB_VERSION_MALFORMED",
+            language: target,
+            message: `Stdlib provider version '${String(version)}' is not a strict semantic version.`
+        });
+    }
+    const operations = /** @type {unknown} */ (provision.operations);
+    if (!isDenseArray(operations) || operations.length == 0 || !operations.every((operation) => typeof operation == "string" && /^[A-Za-z_][A-Za-z0-9_]*$/u.test(operation)) ||
+        new Set(/** @type {string[]} */ (operations)).size != operations.length) {
+        invalidProvider(`Stdlib provider '${identity}' declares invalid operations.`);
+    }
+    const operationList = /** @type {string[]} */ (operations);
+    if (moduleKnown(module))
+        validateProvision(module, version, operationList);
+    const nativeEntries = /** @type {unknown} */ (candidate.nativeEntries);
+    if (!isPlainObject(nativeEntries) || Object.keys(nativeEntries).sort().join(",") !=
+        [...operationList].sort().join(",")) {
+        invalidProvider(`Stdlib provider '${identity}' native entries must match its operations exactly.`);
+    }
+    for (const operation of operationList) {
+        const expectedEntry = module == probeIdentity
+            ? protectedEntryName(target, operation)
+            : protectedEntryName(target, module, operation);
+        if ( /** @type {string} */(nativeEntries[operation]) != expectedEntry) {
+            invalidProvider(`Stdlib provider '${identity}' declares an invalid protected native entry.`);
+        }
+    }
+    const artifact = /** @type {unknown} */ (candidate.artifact);
+    if (!isPlainObject(artifact) || Object.keys(artifact).sort().join(",") != "mediaType,path") {
+        invalidProvider(`Stdlib provider '${identity}' declares an invalid artifact.`);
+    }
+    const mediaType = /** @type {string} */ (artifact.mediaType);
+    const path = /** @type {string} */ (artifact.path);
+    const derivedPath = `providers/${target}/${module.replaceAll(".", "/")}.${targetExtensions[target]}`;
+    if (typeof mediaType != "string" || mediaType.length == 0 || typeof path != "string" ||
+        path != derivedPath || !isSafeArtifactPath(path)) {
+        invalidProvider(`Stdlib provider '${identity}' artifact must be generated at '${derivedPath}'.`);
+    }
+    const dependencies = /** @type {unknown} */ (candidate.dependencies);
+    if (!isDenseArray(dependencies))
+        invalidProvider(`Stdlib provider '${identity}' dependencies must be a dense array.`);
+    /** @type {{module: string, range: string}[]} */
+    const validatedDependencies = [];
+    for (const dependency of dependencies) {
+        if (!isPlainObject(dependency) || Object.keys(dependency).sort().join(",") != "module,range") {
+            invalidProvider(`Stdlib provider '${identity}' declares an invalid dependency.`);
+        }
+        const dependencyModule = /** @type {string} */ (dependency.module);
+        const dependencyRange = /** @type {string} */ (dependency.range);
+        if (typeof dependencyModule != "string" || !/^[a-z][a-z0-9.-]*$/u.test(dependencyModule) ||
+            parseStdlibVersionRange(dependencyRange) === null) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_VERSION_MALFORMED",
+                language: target,
+                message: `Stdlib provider dependency range '${String(dependencyRange)}' is not a canonical version range.`
+            });
+        }
+        validatedDependencies.push({ module: dependencyModule, range: /** @type {string} */ (dependencyRange) });
+    }
+    const runtimeProfile = /** @type {string} */ (candidate.runtimeProfile);
+    if (typeof runtimeProfile != "string" || !/^[a-z][a-z0-9-]*-v[1-9][0-9]*$/u.test(runtimeProfile)) {
+        invalidProvider(`Stdlib provider '${identity}' declares an invalid runtime profile.`);
+    }
+    if (module != probeIdentity && (target != "php" || runtimeProfile != "php82-core-streams-v1")) {
+        invalidProvider(`Stdlib provider '${identity}' does not use the Task 037 PHP 8.2 core-streams profile.`);
+    }
+    return deepFreeze(/** @type {StdlibProviderRecord} */ ({
+        artifact: { mediaType, path },
+        dependencies: validatedDependencies,
+        identity,
+        nativeEntries: Object.freeze(Object.fromEntries(operationList.map((operation) => [
+            operation,
+            /** @type {string} */ (nativeEntries[operation])
+        ]))),
+        provides: [{ module, operations: operationList, version: /** @type {string} */ (version) }],
+        runtimeProfile,
+        target
+    }));
+}
+/**
+ * Checks the provisioned module version and operations against the canonical contract registry.
+ * @param {string} module - Canonical module identity.
+ * @param {string} version - Strict provider version.
+ * @param {string[]} operations - Provided operations.
+ * @returns {void}
+ */
+function validateProvision(module, version, operations) {
+    const listed = listStdlibModules().find(({ identity }) => identity == module);
+    if (!listed || !listed.versions.includes(version)) {
+        invalidProvider(`Stdlib provider version '${version}' is not registered for module '${module}'.`);
+    }
+    const declared = new Set(resolveStdlibModule(module, version).operations.map(({ name }) => name));
+    for (const operation of operations) {
+        if (!declared.has(operation)) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_OPERATION_UNDECLARED",
+                language: module,
+                message: `Operation '${operation}' is not declared by canonical module '${module}'.`
+            });
+        }
+    }
+}
+/**
+ * Reports whether a target is registered with the provider role.
+ * @param {unknown} target - Candidate target identity.
+ * @returns {boolean} Whether the target adopts the provider role.
+ */
+function providerTargetRegistered(target) {
+    if (typeof target != "string")
+        return false;
+    try {
+        return languageRegistry.record(target).provider === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Reports whether a module identity is known to the built-in canonical contract registry.
+ * @param {string} module - Canonical module identity.
+ * @returns {boolean} Whether the identity resolves.
+ */
+function moduleKnown(module) {
+    try {
+        resolveStdlibModule(module);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Builds the built-in provider records for the adopted targets.
+ * @returns {unknown[]} Unvalidated built-in records.
+ */
+function builtinProviderRecords() {
+    const probeProviders = builtinProviderTargets.map((target) => ({
+        artifact: {
+            mediaType: /** @type {string} */ (languageRegistry.record(target).mediaType),
+            path: `providers/${target}/${probeIdentity.replaceAll(".", "/")}.${targetExtensions[target]}`
+        },
+        dependencies: [],
+        identity: `semantifold.provider.${target}.${probeIdentity}`,
+        nativeEntries: Object.fromEntries(probeOperations.map((operation) => [operation, protectedEntryName(target, operation)])),
+        provides: [{ module: probeIdentity, operations: [...probeOperations], version: "1.0.0" }],
+        runtimeProfile: legacyRuntimeProfiles[target],
+        target
+    }));
+    const task037Providers = task037ProviderModules.map((module) => ({
+        artifact: {
+            mediaType: /** @type {string} */ (languageRegistry.record("php").mediaType),
+            path: `providers/php/${module.identity.replaceAll(".", "/")}.php`
+        },
+        dependencies: module.dependencies,
+        identity: `semantifold.provider.php.${module.identity}`,
+        nativeEntries: Object.fromEntries(module.operations.map((operation) => [
+            operation,
+            protectedEntryName("php", module.identity, operation)
+        ])),
+        provides: [{ module: module.identity, operations: module.operations, version: "1.0.0" }],
+        runtimeProfile: "php82-core-streams-v1",
+        target: "php"
+    }));
+    return [...probeProviders, ...task037Providers];
+}
+/** @type {Readonly<StdlibProviderRegistry> | null} */
+let builtinProviderRegistryValue = null;
+/**
+ * Lazily materializes the built-in provider registry after language-registry initialization.
+ * @returns {Readonly<StdlibProviderRegistry>} Built-in registry.
+ */
+function builtinProviderRegistry() {
+    if (builtinProviderRegistryValue === null) {
+        builtinProviderRegistryValue = createStdlibProviderRegistry(builtinProviderRecords());
+    }
+    return builtinProviderRegistryValue;
+}
+/**
+ * Throws a normalized provider-registry diagnostic.
+ * @param {string} message - Failure detail.
+ * @returns {never} Always throws.
+ */
+function invalidProvider(message) {
+    throw new SemantifoldDiagnostic({ code: "STDLIB_PROVIDER_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-providers.js","sourceRoot":"","sources":["../../src/stdlib-providers.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {isDenseArray} from \"./array.js\"\nimport {isSafeArtifactPath} from \"./artifact-path.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {languageRegistry} from \"./language-registry.js\"\nimport {\n  listStdlibModules,\n  parseStdlibVersion,\n  parseStdlibVersionRange,\n  protectedEntryName,\n  resolveStdlibModule\n} from \"./semantic/stdlib.js\"\n\nexport {protectedEntryName} from \"./semantic/stdlib.js\"\n\n/**\n * @typedef StdlibProviderRecord\n * @property {{mediaType: string, path: string}} artifact - Generated provider artifact declaration.\n * @property {readonly {module: string, range: string}[]} dependencies - Canonical module dependencies with declared ranges.\n * @property {string} identity - Stable provider identity rooted at the target.\n * @property {Readonly<Record<string, string>>} nativeEntries - Operation to protected native entry name.\n * @property {readonly {module: string, operations: string[], version: string}[]} provides - Exactly one provided canonical module.\n * @property {string} runtimeProfile - Closed target runtime/provider profile.\n * @property {string} target - Adopted target language identity.\n */\n\n/**\n * @typedef StdlibProviderRegistry\n * @property {readonly StdlibProviderRecord[]} records - Registered provider records in stable order.\n * @property {{(target: string, module: string, version: string): readonly StdlibProviderRecord[]}} providersFor - Exact provider lookup.\n */\n\nconst providerIdentityPrefix = \"semantifold.provider.\"\n/** @type {Readonly<Record<string, string>>} */\nconst targetExtensions = Object.freeze({\n  javascript: \"js\",\n  java: \"java\",\n  php: \"php\",\n  ruby: \"rb\",\n  typescript: \"ts\"\n})\nconst builtinProviderTargets = Object.freeze([\"php\", \"ruby\", \"javascript\", \"typescript\", \"java\"])\nconst probeIdentity = \"semantifold.task034.resource-probe\"\nconst probeOperations = Object.freeze([\"probeEffect\", \"probeAcquire\", \"probeRead\", \"probeClose\", \"probeTrace\"])\nconst recordKeys = Object.freeze([\"artifact\", \"dependencies\", \"identity\", \"nativeEntries\", \"provides\", \"runtimeProfile\", \"target\"])\nconst task037ProviderModules = Object.freeze([\n  Object.freeze({dependencies: [], identity: \"semantifold.resource\", operations: [\"v1_close\"]}),\n  Object.freeze({dependencies: [{module: \"semantifold.resource\", range: \"1\"}], identity: \"semantifold.socket-client\", operations: [\"v1_connect\"]}),\n  Object.freeze({dependencies: [{module: \"semantifold.resource\", range: \"1\"}], identity: \"semantifold.text-stream\", operations: [\"v1_read_line\"]}),\n  Object.freeze({dependencies: [], identity: \"semantifold.output\", operations: [\"v1_write_line\"]})\n])\n/** @type {Readonly<Record<string, string>>} */\nconst legacyRuntimeProfiles = Object.freeze({\n  javascript: \"node24-core-v1\",\n  java: \"java17-core-v1\",\n  php: \"php82-core-v1\",\n  ruby: \"ruby3-core-v1\",\n  typescript: \"node24-typescript7-core-v1\"\n})\n\n/**\n * Creates the versioned target host stdlib provider registry.\n * @param {unknown} records - Ordered provider records; built-in providers by default.\n * @returns {Readonly<StdlibProviderRegistry>} Frozen registry.\n */\nexport function createStdlibProviderRegistry(records = builtinProviderRecords()) {\n  if (!isDenseArray(records)) invalidProvider(\"Provider records must be an ordered dense array.\")\n\n  /** @type {StdlibProviderRecord[]} */\n  const validated = []\n  /** @type {Set<string>} */\n  const identities = new Set()\n\n  for (const candidate of records) {\n    const record = validateProviderRecord(candidate)\n\n    if (identities.has(record.identity)) invalidProvider(`Duplicate stdlib provider identity '${record.identity}'.`)\n    identities.add(record.identity)\n    validated.push(record)\n  }\n  const frozenRecords = deepFreeze(validated)\n\n  return Object.freeze(/** @type {Readonly<StdlibProviderRegistry>} */ ({\n    records: frozenRecords,\n    providersFor(target, module, version) {\n      if (typeof target != \"string\" || typeof module != \"string\" || typeof version != \"string\") return Object.freeze([])\n      return Object.freeze(frozenRecords.filter((record) =>\n        record.target == target && record.provides[0].module == module && record.provides[0].version == version))\n    }\n  }))\n}\n\n/**\n * Lists the built-in target host providers for the probe contract in stable target order.\n * @returns {readonly StdlibProviderRecord[]} Frozen provider records.\n */\nexport function listStdlibProviders() {\n  return builtinProviderRegistry().records\n}\n\n/**\n * Authoritative built-in provider lookup keyed by exact target, module, and version.\n * @type {{providersFor(target: string, module: string, version: string): readonly StdlibProviderRecord[]}}\n */\nexport const stdlibProviderRegistry = {\n  providersFor(target, module, version) {\n    return builtinProviderRegistry().providersFor(target, module, version)\n  }\n}\n\n/**\n * Validates one provider record against the target roles and canonical contract registry.\n * @param {unknown} candidate - Candidate record.\n * @returns {StdlibProviderRecord} Detached frozen record.\n */\nfunction validateProviderRecord(candidate) {\n  if (!isPlainObject(candidate)) invalidProvider(\"Every stdlib provider record must be a plain object.\")\n  if (Object.keys(candidate).sort().join(\",\") != recordKeys.join(\",\")) {\n    invalidProvider(\"Every stdlib provider record declares the exact provider record fields.\")\n  }\n  const target = /** @type {string} */ (candidate.target)\n\n  if (typeof target != \"string\" || !providerTargetRegistered(target)) {\n    invalidProvider(`Stdlib provider target '${String(target)}' is not an adopted target host provider.`)\n  }\n  const identity = /** @type {string} */ (candidate.identity)\n  const identityPrefix = providerIdentityPrefix + target + \".\"\n\n  if (typeof identity != \"string\" || !identity.startsWith(identityPrefix) || identity.length == identityPrefix.length) {\n    invalidProvider(`Stdlib provider identity '${String(identity)}' must be rooted at '${identityPrefix}'.`)\n  }\n  const provides = /** @type {unknown} */ (candidate.provides)\n\n  if (!isDenseArray(provides) || provides.length != 1) invalidProvider(\"Every stdlib provider provides exactly one canonical module.\")\n  const provision = /** @type {unknown} */ (provides[0])\n\n  if (!isPlainObject(provision) || Object.keys(provision).sort().join(\",\") != \"module,operations,version\") {\n    invalidProvider(\"Every stdlib provider provision declares the exact provision fields.\")\n  }\n  const module = /** @type {string} */ (provision.module)\n\n  if (typeof module != \"string\" || !/^[a-z][a-z0-9.-]*$/u.test(module)) {\n    invalidProvider(`Stdlib provider module '${String(module)}' is not a canonical identity.`)\n  }\n  const version = /** @type {string} */ (provision.version)\n\n  if (parseStdlibVersion(version) === null) {\n    throw new SemantifoldDiagnostic({\n      code: \"STDLIB_VERSION_MALFORMED\",\n      language: target,\n      message: `Stdlib provider version '${String(version)}' is not a strict semantic version.`\n    })\n  }\n  const operations = /** @type {unknown} */ (provision.operations)\n\n  if (!isDenseArray(operations) || operations.length == 0 || !operations.every((operation) =>\n    typeof operation == \"string\" && /^[A-Za-z_][A-Za-z0-9_]*$/u.test(operation)) ||\n    new Set(/** @type {string[]} */ (operations)).size != operations.length) {\n    invalidProvider(`Stdlib provider '${identity}' declares invalid operations.`)\n  }\n  const operationList = /** @type {string[]} */ (operations)\n\n  if (moduleKnown(module)) validateProvision(module, version, operationList)\n  const nativeEntries = /** @type {unknown} */ (candidate.nativeEntries)\n\n  if (!isPlainObject(nativeEntries) || Object.keys(nativeEntries).sort().join(\",\") !=\n    [...operationList].sort().join(\",\")) {\n    invalidProvider(`Stdlib provider '${identity}' native entries must match its operations exactly.`)\n  }\n  for (const operation of operationList) {\n    const expectedEntry = module == probeIdentity\n      ? protectedEntryName(target, operation)\n      : protectedEntryName(target, module, operation)\n\n    if (/** @type {string} */ (nativeEntries[operation]) != expectedEntry) {\n      invalidProvider(`Stdlib provider '${identity}' declares an invalid protected native entry.`)\n    }\n  }\n  const artifact = /** @type {unknown} */ (candidate.artifact)\n\n  if (!isPlainObject(artifact) || Object.keys(artifact).sort().join(\",\") != \"mediaType,path\") {\n    invalidProvider(`Stdlib provider '${identity}' declares an invalid artifact.`)\n  }\n  const mediaType = /** @type {string} */ (artifact.mediaType)\n  const path = /** @type {string} */ (artifact.path)\n  const derivedPath = `providers/${target}/${module.replaceAll(\".\", \"/\")}.${targetExtensions[target]}`\n\n  if (typeof mediaType != \"string\" || mediaType.length == 0 || typeof path != \"string\" ||\n    path != derivedPath || !isSafeArtifactPath(path)) {\n    invalidProvider(`Stdlib provider '${identity}' artifact must be generated at '${derivedPath}'.`)\n  }\n  const dependencies = /** @type {unknown} */ (candidate.dependencies)\n\n  if (!isDenseArray(dependencies)) invalidProvider(`Stdlib provider '${identity}' dependencies must be a dense array.`)\n  /** @type {{module: string, range: string}[]} */\n  const validatedDependencies = []\n\n  for (const dependency of dependencies) {\n    if (!isPlainObject(dependency) || Object.keys(dependency).sort().join(\",\") != \"module,range\") {\n      invalidProvider(`Stdlib provider '${identity}' declares an invalid dependency.`)\n    }\n    const dependencyModule = /** @type {string} */ (dependency.module)\n    const dependencyRange = /** @type {string} */ (dependency.range)\n\n    if (typeof dependencyModule != \"string\" || !/^[a-z][a-z0-9.-]*$/u.test(dependencyModule) ||\n      parseStdlibVersionRange(dependencyRange) === null) {\n      throw new SemantifoldDiagnostic({\n        code: \"STDLIB_VERSION_MALFORMED\",\n        language: target,\n        message: `Stdlib provider dependency range '${String(dependencyRange)}' is not a canonical version range.`\n      })\n    }\n    validatedDependencies.push({module: dependencyModule, range: /** @type {string} */ (dependencyRange)})\n  }\n  const runtimeProfile = /** @type {string} */ (candidate.runtimeProfile)\n\n  if (typeof runtimeProfile != \"string\" || !/^[a-z][a-z0-9-]*-v[1-9][0-9]*$/u.test(runtimeProfile)) {\n    invalidProvider(`Stdlib provider '${identity}' declares an invalid runtime profile.`)\n  }\n  if (module != probeIdentity && (target != \"php\" || runtimeProfile != \"php82-core-streams-v1\")) {\n    invalidProvider(`Stdlib provider '${identity}' does not use the Task 037 PHP 8.2 core-streams profile.`)\n  }\n  return deepFreeze(/** @type {StdlibProviderRecord} */ ({\n    artifact: {mediaType, path},\n    dependencies: validatedDependencies,\n    identity,\n    nativeEntries: Object.freeze(Object.fromEntries(operationList.map((operation) => [\n      operation,\n      /** @type {string} */ (nativeEntries[operation])\n    ]))),\n    provides: [{module, operations: operationList, version: /** @type {string} */ (version)}],\n    runtimeProfile,\n    target\n  }))\n}\n\n/**\n * Checks the provisioned module version and operations against the canonical contract registry.\n * @param {string} module - Canonical module identity.\n * @param {string} version - Strict provider version.\n * @param {string[]} operations - Provided operations.\n * @returns {void}\n */\nfunction validateProvision(module, version, operations) {\n  const listed = listStdlibModules().find(({identity}) => identity == module)\n\n  if (!listed || !listed.versions.includes(version)) {\n    invalidProvider(`Stdlib provider version '${version}' is not registered for module '${module}'.`)\n  }\n  const declared = new Set(resolveStdlibModule(module, version).operations.map(({name}) => name))\n\n  for (const operation of operations) {\n    if (!declared.has(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\n/**\n * Reports whether a target is registered with the provider role.\n * @param {unknown} target - Candidate target identity.\n * @returns {boolean} Whether the target adopts the provider role.\n */\nfunction providerTargetRegistered(target) {\n  if (typeof target != \"string\") return false\n  try {\n    return languageRegistry.record(target).provider === true\n  } catch {\n    return false\n  }\n}\n\n/**\n * Reports whether a module identity is known to the built-in canonical contract registry.\n * @param {string} module - Canonical module identity.\n * @returns {boolean} Whether the identity resolves.\n */\nfunction moduleKnown(module) {\n  try {\n    resolveStdlibModule(module)\n    return true\n  } catch {\n    return false\n  }\n}\n\n/**\n * Builds the built-in provider records for the adopted targets.\n * @returns {unknown[]} Unvalidated built-in records.\n */\nfunction builtinProviderRecords() {\n  const probeProviders = builtinProviderTargets.map((target) => ({\n    artifact: {\n      mediaType: /** @type {string} */ (languageRegistry.record(target).mediaType),\n      path: `providers/${target}/${probeIdentity.replaceAll(\".\", \"/\")}.${targetExtensions[target]}`\n    },\n    dependencies: [],\n    identity: `semantifold.provider.${target}.${probeIdentity}`,\n    nativeEntries: Object.fromEntries(probeOperations.map((operation) => [operation, protectedEntryName(target, operation)])),\n    provides: [{module: probeIdentity, operations: [...probeOperations], version: \"1.0.0\"}],\n    runtimeProfile: legacyRuntimeProfiles[target],\n    target\n  }))\n  const task037Providers = task037ProviderModules.map((module) => ({\n    artifact: {\n      mediaType: /** @type {string} */ (languageRegistry.record(\"php\").mediaType),\n      path: `providers/php/${module.identity.replaceAll(\".\", \"/\")}.php`\n    },\n    dependencies: module.dependencies,\n    identity: `semantifold.provider.php.${module.identity}`,\n    nativeEntries: Object.fromEntries(module.operations.map((operation) => [\n      operation,\n      protectedEntryName(\"php\", module.identity, operation)\n    ])),\n    provides: [{module: module.identity, operations: module.operations, version: \"1.0.0\"}],\n    runtimeProfile: \"php82-core-streams-v1\",\n    target: \"php\"\n  }))\n\n  return [...probeProviders, ...task037Providers]\n}\n\n/** @type {Readonly<StdlibProviderRegistry> | null} */\nlet builtinProviderRegistryValue = null\n\n/**\n * Lazily materializes the built-in provider registry after language-registry initialization.\n * @returns {Readonly<StdlibProviderRegistry>} Built-in registry.\n */\nfunction builtinProviderRegistry() {\n  if (builtinProviderRegistryValue === null) {\n    builtinProviderRegistryValue = createStdlibProviderRegistry(builtinProviderRecords())\n  }\n  return builtinProviderRegistryValue\n}\n\n/**\n * Throws a normalized provider-registry diagnostic.\n * @param {string} message - Failure detail.\n * @returns {never} Always throws.\n */\nfunction invalidProvider(message) {\n  throw new SemantifoldDiagnostic({code: \"STDLIB_PROVIDER_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/toolchains.d.ts

@@ -1,10 +1,22 @@
 export declare const canonicalToolchains: {
+    dart: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
     php: {
         canonicalCommand: string;
         overrideEnvironmentVariable: string;
         supportedVersion: RegExp;
         versionArguments: string[];
     };
+    php82: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
     ruby: {
         canonicalCommand: string;
         overrideEnvironmentVariable: string;
@@ -35,6 +47,18 @@ export declare const canonicalToolchains: {
         supportedVersion: RegExp;
         versionArguments: string[];
     };
+    java25: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
+    kotlinc: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
     python: {
         canonicalCommand: string;
         overrideEnvironmentVariable: string;
@@ -65,6 +89,36 @@ export declare const canonicalToolchains: {
         supportedVersion: RegExp;
         versionArguments: string[];
     };
+    rustc: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
+    cargo: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
+    swiftc: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
+    "wasm-validate": {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
+    chromium: {
+        canonicalCommand: string;
+        overrideEnvironmentVariable: string;
+        supportedVersion: RegExp;
+        versionArguments: string[];
+    };
 };
 /**
  * Discovers one repository-declared canonical toolchain.
@@ -84,7 +138,7 @@ export declare function discoverCanonicalToolchain(id: keyof typeof canonicalToo
  * @param {Readonly<Record<string, string | undefined>>} [input.environment] - Explicit discovery environment.
  * @param {string} input.id - Toolchain ID.
  * @param {string} [input.override] - Configured absolute executable path.
- * @param {RegExp} [input.supportedVersion] - Full captured-output version policy.
+ * @param {RegExp} [input.supportedVersion] - Full selected-stream version policy.
  * @param {number} [input.timeoutMs] - Version command timeout.
  * @param {string[]} input.versionArguments - Exact version argument array.
  * @returns {Promise<import("./semantic/types.js").DiscoveredToolchain>} Discovered tool.

package/build/src/toolchains.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolchains.d.ts","sourceRoot":"","sources":["../../src/toolchains.js"],"names":[],"mappings":"AAYA,eAAO,MAAM,mBAAmB;;0BAsKA,MAAM;qCAA+B,MAAM;0BAAoB,MAAM;0BAAoB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA1J/H,CAAA;AAEF;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,EAAE,EAJxC,MAAM,OAAO,mBAI2B,EAAE,OAAO,AAHzD,CACA,EADQ;IAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAG5C,GAFpD,OAAO,CAAC,OAAO,qBAAqB,EAAE,mBAAmB,CAAC,CA+BtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAT1C;IAAsB,gBAAgB,EAA9B,MAAM,CACd;IAA6D,WAAW,AAAxE,CACA,EADQ,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CACpD;IAAsB,EAAE,EAAhB,MAAM,CACd;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAAuB,gBAAgB,AAAvC,CACA,EADQ,MAAM,CACd;IAAuB,SAAS,AAAhC,CACA,EADQ,MAAM,CACd;IAAwB,gBAAgB,EAAhC,MAAM,EAAE,CAChB;CAE0C,GAFhC,OAAO,CAAC,OAAO,qBAAqB,EAAE,mBAAmB,CAAC,CAiGtE;AA+HD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,GAHzC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAGqB,GAF9D,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqB5C"}
+{"version":3,"file":"toolchains.d.ts","sourceRoot":"","sources":["../../src/toolchains.js"],"names":[],"mappings":"AAYA,eAAO,MAAM,mBAAmB;;0BAmLA,MAAM;qCAA+B,MAAM;0BAAoB,MAAM;0BAAoB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA5J/H,CAAA;AAEF;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,EAAE,EAJxC,MAAM,OAAO,mBAI2B,EAAE,OAAO,AAHzD,CACA,EADQ;IAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAG5C,GAFpD,OAAO,CAAC,OAAO,qBAAqB,EAAE,mBAAmB,CAAC,CA+BtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAT1C;IAAsB,gBAAgB,EAA9B,MAAM,CACd;IAA6D,WAAW,AAAxE,CACA,EADQ,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CACpD;IAAsB,EAAE,EAAhB,MAAM,CACd;IAAuB,QAAQ,AAA/B,CACA,EADQ,MAAM,CACd;IAAuB,gBAAgB,AAAvC,CACA,EADQ,MAAM,CACd;IAAuB,SAAS,AAAhC,CACA,EADQ,MAAM,CACd;IAAwB,gBAAgB,EAAhC,MAAM,EAAE,CAChB;CAE0C,GAFhC,OAAO,CAAC,OAAO,qBAAqB,EAAE,mBAAmB,CAAC,CAmGtE;AA+HD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,GAHzC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAGqB,GAF9D,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqB5C"}