semantifold 0.3.0 → 0.5.0

package/build/src/semantic/stdlib.js

@@ -0,0 +1,880 @@
+// @ts-check
+import { SemantifoldDiagnostic } from "../diagnostic.js";
+const identityPattern = /^[a-z][a-z0-9.-]*$/u;
+const declarationNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+const scalarNames = new Set(["boolean", "integer", "string"]);
+const component = "(0|[1-9][0-9]*)";
+const exactVersionPattern = new RegExp(`^${component}\\.${component}\\.${component}$`, "u");
+const rangePattern = new RegExp(`^${component}(?:\\.${component}){0,2}$`, "u");
+const semanticsValues = {
+    blocking: new Set(["synchronous"]),
+    close: new Set(["not-applicable", "use-after-close-fails", "repeated-close-fails"]),
+    eof: new Set(["not-applicable", "absent-value"]),
+    encoding: new Set(["not-applicable", "utf-8"]),
+    newline: new Set(["not-applicable", "strip-line-terminator", "retain-line-terminator", "append-lf-if-missing"]),
+    ownership: new Set(["not-applicable", "acquired", "borrowed", "consumed"]),
+    timeout: new Set(["none"])
+};
+/** @typedef {[number, number, number]} VersionTuple */
+/** @typedef {{lower: VersionTuple, upper: VersionTuple | null}} VersionRange */
+/** @typedef {{module: string, name: string}} CanonicalDeclarationReference */
+/**
+ * @typedef StdlibContractOperation
+ * @property {{module: string, operation: string, range: VersionRange}[]} dependencies - Canonical operation dependencies.
+ * @property {["host"]} effects - Closed effect declaration.
+ * @property {"left-to-right"} evaluationOrder - Canonical argument evaluation order.
+ * @property {(string | CanonicalDeclarationReference)[]} failures - Declared failure names.
+ * @property {string} name - Operation name.
+ * @property {{name: string, type: string | CanonicalDeclarationReference}[]} parameters - Ordered parameters.
+ * @property {object} resourceFlow - Closed resource transition.
+ * @property {string | CanonicalDeclarationReference} returnType - Closed return type spelling.
+ * @property {Record<string, string>} semantics - Closed canonical semantics fields.
+ */
+/**
+ * @typedef StdlibContractModule
+ * @property {{module: string, range: VersionRange}[]} dependencies - Versioned declaration dependencies.
+ * @property {{name: string}[]} failures - Ordered failure declarations.
+ * @property {string} identity - Canonical module identity.
+ * @property {StdlibContractOperation[]} operations - Ordered operation declarations.
+ * @property {{name: string}[]} resources - Ordered resource declarations.
+ * @property {string} version - Exact registered version.
+ */
+/**
+ * @typedef StdlibContract
+ * @property {{module: string, range: VersionRange}[]} dependencies - Versioned declaration dependencies.
+ * @property {{name: string}[]} failures - Ordered failure declarations.
+ * @property {string} identity - Canonical module identity.
+ * @property {StdlibContractOperation[]} operations - Ordered operation declarations.
+ * @property {{name: string}[]} resources - Ordered resource declarations.
+ * @property {"SemantifoldStdlibContract"} schema - Contract schema discriminator.
+ * @property {1} schemaVersion - Contract schema version.
+ * @property {string} version - Resolved exact version.
+ */
+/**
+ * @typedef StdlibContractRegistry
+ * @property {{identity: string, versions: string[]}[]} modules - Registered modules in stable order.
+ * @property {(identity: string, range?: string) => StdlibContract} resolveModule - Versioned module resolution.
+ */
+/**
+ * Parses one exact X.Y.Z standard-library version.
+ * @param {unknown} value - Candidate version.
+ * @returns {VersionTuple | null} Parsed version or null when malformed.
+ */
+export function parseStdlibVersion(value) {
+    if (typeof value != "string" || !exactVersionPattern.test(value))
+        return null;
+    const [major, minor, patch] = value.split(".").map((part) => Number(part));
+    return [major, minor, patch];
+}
+/**
+ * Parses one X, X.Y, or X.Y.Z standard-library version range.
+ * @param {unknown} value - Candidate range.
+ * @returns {VersionRange | null} Half-open range or null when malformed.
+ */
+export function parseStdlibVersionRange(value) {
+    if (typeof value != "string" || !rangePattern.test(value))
+        return null;
+    const parts = value.split(".").map((part) => Number(part));
+    const major = parts[0];
+    const minor = parts.length > 1 ? parts[1] : 0;
+    const patch = parts.length > 2 ? parts[2] : 0;
+    if (parts.length == 1)
+        return { lower: [major, 0, 0], upper: [major + 1, 0, 0] };
+    if (parts.length == 2)
+        return { lower: [major, minor, 0], upper: [major, minor + 1, 0] };
+    return { lower: [major, minor, patch], upper: [major, minor, patch + 1] };
+}
+/**
+ * Compares two exact version tuples.
+ * @param {VersionTuple} left - Left version.
+ * @param {VersionTuple} right - Right version.
+ * @returns {number} Negative, zero, or positive ordering.
+ */
+export function compareStdlibVersions(left, right) {
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] != right[index])
+            return left[index] < right[index] ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * Derives one protected native provider entry name.
+ * @param {string} target - Adopted provider target language.
+ * @param {string} module - Legacy operation name or canonical module identity.
+ * @param {string} [operation] - Qualified canonical operation name.
+ * @returns {string} Protected native entry name.
+ */
+export function protectedEntryName(target, module, operation) {
+    if (typeof target != "string" || !/^[a-z][a-z0-9-]*$/u.test(target) ||
+        typeof module != "string" || (operation !== undefined && (typeof operation != "string" ||
+        !declarationNamePattern.test(operation))))
+        invalidContract("Protected provider entry components are invalid.");
+    if (operation === undefined) {
+        if (!declarationNamePattern.test(module))
+            invalidContract("Protected provider operation name is invalid.");
+        return `__semantifold_provider_${target}_${module}`;
+    }
+    if (!identityPattern.test(module))
+        invalidContract("Protected provider module identity is invalid.");
+    const encodedModule = [...module].map((character) => character.charCodeAt(0).toString(16).padStart(2, "0")).join("");
+    return `__semantifold_provider_${target}_m${encodedModule.length}_${encodedModule}_${operation}`;
+}
+/**
+ * Parses one protected native provider entry name.
+ * @param {string} name - Candidate protected entry name.
+ * @returns {{target: string, module?: string, operation: string} | null} Parsed binding or null when unparseable.
+ */
+export function parseProtectedEntryName(name) {
+    const qualified = /^__semantifold_provider_([a-z][a-z0-9-]*)_m([0-9]+)_([0-9a-f]+)_([A-Za-z_][A-Za-z0-9_]*)$/u.exec(name);
+    if (qualified) {
+        const encodedLength = Number(qualified[2]);
+        const encoded = qualified[3];
+        if (!Number.isSafeInteger(encodedLength) || encodedLength != encoded.length || encoded.length % 2 != 0)
+            return null;
+        let module = "";
+        for (let index = 0; index < encoded.length; index += 2)
+            module += String.fromCharCode(Number.parseInt(encoded.slice(index, index + 2), 16));
+        if (!identityPattern.test(module) || protectedEntryName(qualified[1], module, qualified[4]) != name)
+            return null;
+        return { module, operation: qualified[4], target: qualified[1] };
+    }
+    const match = /^__semantifold_provider_([a-z][a-z0-9-]*)_(.+)$/u.exec(name);
+    if (!match)
+        return null;
+    return { operation: match[2], target: match[1] };
+}
+/**
+ * Intersects two half-open version ranges.
+ * @param {VersionRange} left - Left range.
+ * @param {VersionRange} right - Right range.
+ * @returns {VersionRange | null} Intersection or null when empty.
+ */
+export function intersectStdlibVersionRanges(left, right) {
+    const lower = compareStdlibVersions(left.lower, right.lower) >= 0 ? left.lower : right.lower;
+    const upper = left.upper === null ? right.upper : right.upper === null ? left.upper :
+        compareStdlibVersions(left.upper, right.upper) <= 0 ? left.upper : right.upper;
+    if (upper !== null && compareStdlibVersions(lower, upper) >= 0)
+        return null;
+    return { lower, upper };
+}
+/**
+ * Checks whether one exact version satisfies one half-open range.
+ * @param {VersionTuple} version - Candidate version.
+ * @param {VersionRange} range - Declared range.
+ * @returns {boolean} Whether the version satisfies the range.
+ */
+export function stdlibVersionSatisfies(version, range) {
+    if (compareStdlibVersions(version, range.lower) < 0)
+        return false;
+    return range.upper === null || compareStdlibVersions(version, range.upper) < 0;
+}
+/**
+ * Creates the built-in versioned canonical stdlib contract registry.
+ * @param {unknown} records - Optional override record set; built-in probe contract by default.
+ * @returns {Readonly<StdlibContractRegistry>} Frozen registry.
+ */
+export function createStdlibContractRegistry(records = builtinContracts()) {
+    if (!isDenseArray(records))
+        invalidContract("Canonical contract records must be an ordered dense array.");
+    /** @type {Map<string, Map<string, StdlibContractModule>>} */
+    const modules = new Map();
+    for (const candidate of records) {
+        const record = validateContractRecord(candidate);
+        const versions = modules.get(record.identity) ?? new Map();
+        if (versions.has(record.version))
+            invalidContract(`Duplicate canonical contract '${record.identity}' version '${record.version}'.`);
+        versions.set(record.version, record);
+        modules.set(record.identity, versions);
+    }
+    for (const record of modules.values()) {
+        for (const module of record.values())
+            validateContractDependencies(module, modules);
+    }
+    const frozenModules = [...modules.entries()]
+        .map(([identity, versions]) => ({
+        identity,
+        versions: [...versions.keys()].map((version) => /** @type {VersionTuple} */ (parseStdlibVersion(version)))
+            .sort(compareStdlibVersions)
+            .map(([major, minor, patch]) => `${major}.${minor}.${patch}`)
+    }))
+        .map(deepFreeze);
+    const store = deepFreeze(/** @type {{modules: [string, Readonly<Map<string, Readonly<StdlibContractModule>>>][]}} */ ({
+        modules: [...modules.entries()].map(([identity, versions]) => [identity, deepFreeze(versions)])
+    }));
+    return Object.freeze(/** @type {StdlibContractRegistry} */ ({
+        modules: Object.freeze(frozenModules),
+        resolveModule(identity, range) {
+            return resolveRegistryModule(store, identity, range);
+        }
+    }));
+}
+/**
+ * Resolves one module identity plus optional range against one registry store.
+ * @param {{modules: [string, Readonly<Map<string, Readonly<StdlibContractModule>>>][]}} store - Registry store.
+ * @param {string} identity - Canonical module identity.
+ * @param {string | undefined} [range] - Declared version range.
+ * @returns {StdlibContract} Detached frozen contract.
+ */
+function resolveRegistryModule(store, identity, range) {
+    const versions = store.modules.find(([candidate]) => candidate == identity)?.[1];
+    if (!versions)
+        unknownModule(identity);
+    const parsed = range === undefined ? /** @type {VersionRange} */ ({ lower: [0, 0, 0], upper: null }) : parseStdlibVersionRange(range);
+    if (!parsed)
+        malformedRange();
+    /** @type {VersionTuple | undefined} */
+    let resolved;
+    for (const version of versions.keys()) {
+        const tuple = /** @type {VersionTuple} */ (parseStdlibVersion(version));
+        if (stdlibVersionSatisfies(tuple, parsed) && (resolved === undefined || compareStdlibVersions(tuple, resolved) > 0)) {
+            resolved = tuple;
+        }
+    }
+    if (resolved === undefined)
+        incompatibleVersion(identity);
+    const record = /** @type {Readonly<StdlibContractModule>} */ (versions.get(`${resolved[0]}.${resolved[1]}.${resolved[2]}`));
+    return deepFreeze({
+        dependencies: record.dependencies,
+        failures: record.failures,
+        identity: record.identity,
+        operations: record.operations,
+        resources: record.resources,
+        schema: /** @type {const} */ ("SemantifoldStdlibContract"),
+        schemaVersion: /** @type {const} */ (1),
+        version: `${resolved[0]}.${resolved[1]}.${resolved[2]}`
+    });
+}
+/**
+ * Lists the built-in canonical stdlib modules with their registered versions.
+ * @returns {Readonly<{identity: string, versions: string[]}[]>} Frozen module list.
+ */
+export function listStdlibModules() {
+    return builtinRegistry.modules;
+}
+/**
+ * Resolves one built-in canonical stdlib module by identity and optional range.
+ * @param {string} identity - Canonical module identity.
+ * @param {string} [range] - Declared version range.
+ * @returns {StdlibContract} Detached frozen contract.
+ */
+export function resolveStdlibModule(identity, range) {
+    return builtinRegistry.resolveModule(identity, range);
+}
+/**
+ * Declares the built-in Task 034 resource-probe canonical contract.
+ * @returns {unknown} Unvalidated built-in record.
+ */
+function builtinProbeContract() {
+    return {
+        dependencies: [],
+        failures: [
+            { name: "ProbeOperationFailure" },
+            { name: "ProbeAcquireFailure" },
+            { name: "ProbeReadFailure" },
+            { name: "ProbeCloseFailure" },
+            { name: "ProbeResourceClosed" }
+        ],
+        identity: "semantifold.task034.resource-probe",
+        operations: [
+            {
+                dependencies: [],
+                effects: ["host"],
+                evaluationOrder: "left-to-right",
+                failures: ["ProbeOperationFailure"],
+                name: "probeEffect",
+                parameters: [{ name: "label", type: "string" }, { name: "value", type: "integer" }, { name: "fail", type: "boolean" }],
+                resourceFlow: { kind: "none" },
+                returnType: "integer",
+                semantics: canonicalSemantics()
+            },
+            {
+                dependencies: [],
+                effects: ["host"],
+                evaluationOrder: "left-to-right",
+                failures: ["ProbeAcquireFailure"],
+                name: "probeAcquire",
+                parameters: [{ name: "fail", type: "boolean" }],
+                resourceFlow: { kind: "acquire", resource: "ProbeResource" },
+                returnType: "ProbeResource",
+                semantics: canonicalSemantics({ ownership: "acquired" })
+            },
+            {
+                dependencies: [],
+                effects: ["host"],
+                evaluationOrder: "left-to-right",
+                failures: ["ProbeReadFailure", "ProbeResourceClosed"],
+                name: "probeRead",
+                parameters: [{ name: "resource", type: "ProbeResource" }, { name: "fail", type: "boolean" }],
+                resourceFlow: { kind: "borrow", parameterIndex: 0, terminalFailure: "ProbeResourceClosed" },
+                returnType: "optional:string",
+                semantics: canonicalSemantics({
+                    close: "use-after-close-fails",
+                    eof: "absent-value",
+                    encoding: "utf-8",
+                    newline: "strip-line-terminator",
+                    ownership: "borrowed"
+                })
+            },
+            {
+                dependencies: [],
+                effects: ["host"],
+                evaluationOrder: "left-to-right",
+                failures: ["ProbeCloseFailure", "ProbeResourceClosed"],
+                name: "probeClose",
+                parameters: [{ name: "resource", type: "ProbeResource" }, { name: "fail", type: "boolean" }],
+                resourceFlow: { kind: "close", parameterIndex: 0, terminalFailure: "ProbeResourceClosed" },
+                returnType: "void",
+                semantics: canonicalSemantics({ close: "repeated-close-fails", ownership: "consumed" })
+            },
+            {
+                dependencies: [],
+                effects: ["host"],
+                evaluationOrder: "left-to-right",
+                failures: [],
+                name: "probeTrace",
+                parameters: [],
+                resourceFlow: { kind: "none" },
+                returnType: "string",
+                semantics: canonicalSemantics()
+            }
+        ],
+        resources: [{ name: "ProbeResource" }],
+        version: "1.0.0"
+    };
+}
+/**
+ * Declares the complete built-in canonical registry input.
+ * @returns {unknown[]} Unvalidated built-in records.
+ */
+function builtinContracts() {
+    return [builtinProbeContract(), builtinSocketClientContract(), builtinTextStreamContract(),
+        builtinOutputContract(), builtinResourceContract()];
+}
+/**
+ * Declares the built-in SocketClient v1 contract.
+ * @returns {unknown} Unvalidated SocketClient v1 record.
+ */
+function builtinSocketClientContract() {
+    const byteStream = { module: "semantifold.resource", name: "ByteStream" };
+    return {
+        dependencies: [{ module: "semantifold.resource", range: "1" }],
+        failures: [{ name: "InvalidHost" }, { name: "InvalidPort" }, { name: "ConnectionFailure" }],
+        identity: "semantifold.socket-client",
+        operations: [{
+                dependencies: [], effects: ["host"], evaluationOrder: "left-to-right",
+                failures: ["InvalidHost", "InvalidPort", "ConnectionFailure"], name: "v1_connect",
+                parameters: [{ name: "host", type: "string" }, { name: "port", type: "integer" }],
+                resourceFlow: { kind: "acquire", resource: byteStream }, returnType: byteStream,
+                semantics: canonicalSemantics({ ownership: "acquired" })
+            }],
+        resources: [],
+        version: "1.0.0"
+    };
+}
+/**
+ * Declares the built-in TextStream v1 contract.
+ * @returns {unknown} Unvalidated TextStream v1 record.
+ */
+function builtinTextStreamContract() {
+    const byteStream = { module: "semantifold.resource", name: "ByteStream" };
+    const resourceClosed = { module: "semantifold.resource", name: "ResourceClosed" };
+    return {
+        dependencies: [{ module: "semantifold.resource", range: "1" }],
+        failures: [{ name: "ReadFailure" }, { name: "DecodeFailure" }],
+        identity: "semantifold.text-stream",
+        operations: [{
+                dependencies: [], effects: ["host"], evaluationOrder: "left-to-right",
+                failures: ["ReadFailure", "DecodeFailure", resourceClosed], name: "v1_read_line",
+                parameters: [{ name: "resource", type: byteStream }],
+                resourceFlow: { kind: "borrow", parameterIndex: 0, terminalFailure: resourceClosed },
+                returnType: "optional:string",
+                semantics: canonicalSemantics({ close: "use-after-close-fails", eof: "absent-value", encoding: "utf-8",
+                    newline: "retain-line-terminator", ownership: "borrowed" })
+            }],
+        resources: [],
+        version: "1.0.0"
+    };
+}
+/**
+ * Declares the built-in Output v1 contract.
+ * @returns {unknown} Unvalidated Output v1 record.
+ */
+function builtinOutputContract() {
+    return {
+        dependencies: [], failures: [{ name: "WriteFailure" }], identity: "semantifold.output",
+        operations: [{
+                dependencies: [], effects: ["host"], evaluationOrder: "left-to-right", failures: ["WriteFailure"],
+                name: "v1_write_line", parameters: [{ name: "text", type: "string" }], resourceFlow: { kind: "none" },
+                returnType: "void", semantics: canonicalSemantics({ encoding: "utf-8", newline: "append-lf-if-missing" })
+            }],
+        resources: [], version: "1.0.0"
+    };
+}
+/**
+ * Declares the built-in Resource v1 contract.
+ * @returns {unknown} Unvalidated Resource v1 record.
+ */
+function builtinResourceContract() {
+    return {
+        dependencies: [], failures: [{ name: "CloseFailure" }, { name: "ResourceClosed" }], identity: "semantifold.resource",
+        operations: [{
+                dependencies: [], effects: ["host"], evaluationOrder: "left-to-right",
+                failures: ["CloseFailure", "ResourceClosed"], name: "v1_close",
+                parameters: [{ name: "resource", type: "ByteStream" }],
+                resourceFlow: { kind: "close", parameterIndex: 0, terminalFailure: "ResourceClosed" }, returnType: "void",
+                semantics: canonicalSemantics({ close: "repeated-close-fails", ownership: "consumed" })
+            }],
+        resources: [{ name: "ByteStream" }], version: "1.0.0"
+    };
+}
+/**
+ * Builds one closed semantics declaration with canonical defaults.
+ * @param {Partial<Record<keyof typeof semanticsValues, string>>} [overrides] - Non-default closed values.
+ * @returns {Record<string, string>} Closed semantics fields.
+ */
+function canonicalSemantics(overrides = {}) {
+    return {
+        blocking: "synchronous",
+        close: "not-applicable",
+        eof: "not-applicable",
+        encoding: "not-applicable",
+        newline: "not-applicable",
+        ownership: "not-applicable",
+        timeout: "none",
+        ...overrides
+    };
+}
+/**
+ * Validates one canonical contract record and returns a detached clone.
+ * @param {unknown} candidate - Candidate record.
+ * @returns {StdlibContractModule} Detached record.
+ */
+function validateContractRecord(candidate) {
+    if (!isPlainObject(candidate))
+        invalidContract("Every canonical contract record must be a plain object.");
+    requireKeys(candidate, ["dependencies", "failures", "identity", "operations", "resources", "version"], "contract record");
+    const identity = /** @type {string} */ (candidate.identity);
+    if (typeof identity != "string" || !identityPattern.test(identity))
+        invalidContract("Canonical contract identity is invalid.");
+    const version = /** @type {string} */ (candidate.version);
+    if (parseStdlibVersion(version) === null)
+        invalidContract(`Canonical contract version '${String(version)}' is invalid.`);
+    const resources = validateNamedList(candidate.resources, "resource");
+    const failures = validateNamedList(candidate.failures, "failure");
+    const resourceNames = new Set(resources.map(({ name }) => name));
+    const failureNames = new Set(failures.map(({ name }) => name));
+    const operationNames = new Set();
+    const dependencies = validateModuleDependencies(candidate.dependencies, identity);
+    if (!isDenseArray(candidate.operations))
+        invalidContract("Canonical contract operations must be a dense array.");
+    const operations = /** @type {unknown[]} */ (candidate.operations).map((operation) => validateContractOperation(operation, resourceNames, failureNames, operationNames));
+    return deepFreeze({
+        dependencies,
+        failures,
+        identity,
+        operations,
+        resources,
+        version: /** @type {string} */ (version)
+    });
+}
+/**
+ * Validates one canonical contract operation.
+ * @param {unknown} candidate - Candidate operation.
+ * @param {Set<string>} resourceNames - Declared resource names.
+ * @param {Set<string>} failureNames - Declared failure names.
+ * @param {Set<string>} operationNames - Already-declared operation names.
+ * @returns {StdlibContractOperation} Detached operation.
+ */
+function validateContractOperation(candidate, resourceNames, failureNames, operationNames) {
+    if (!isPlainObject(candidate))
+        invalidContract("Every canonical contract operation must be a plain object.");
+    requireKeys(candidate, ["dependencies", "effects", "evaluationOrder", "failures", "name", "parameters", "resourceFlow", "returnType", "semantics"], "contract operation");
+    const name = /** @type {string} */ (candidate.name);
+    if (typeof name != "string" || !declarationNamePattern.test(name) || operationNames.has(name)) {
+        invalidContract("Canonical contract operation name is invalid or duplicate.");
+    }
+    operationNames.add(name);
+    if (!isDenseArray(candidate.effects) || candidate.effects.length != 1 || candidate.effects[0] != "host") {
+        invalidContract(`Operation '${name}' requires the single host effect declaration.`);
+    }
+    if (candidate.evaluationOrder != "left-to-right")
+        invalidContract(`Operation '${name}' requires left-to-right evaluation.`);
+    if (!isDenseArray(candidate.failures)) {
+        invalidContract(`Operation '${name}' declares unknown or duplicate failures.`);
+    }
+    const failures = candidate.failures.map((failure) => normalizeDeclarationReference(failure, failureNames, `Operation '${name}' failure`));
+    if (new Set(failures.map(referenceKey)).size != failures.length)
+        invalidContract(`Operation '${name}' repeats a declared failure.`);
+    const parameterNames = new Set();
+    /** @type {{name: string, type: string | CanonicalDeclarationReference}[]} */
+    const parameters = [];
+    if (!isDenseArray(candidate.parameters))
+        invalidContract(`Operation '${name}' parameters must be a dense array.`);
+    for (const parameter of /** @type {unknown[]} */ (candidate.parameters)) {
+        if (!isPlainObject(parameter))
+            invalidContract(`Operation '${name}' parameters must be plain objects.`);
+        requireKeys(parameter, ["name", "type"], `operation '${name}' parameter`);
+        const parameterName = /** @type {string} */ (parameter.name);
+        if (typeof parameterName != "string" || !declarationNamePattern.test(parameterName) || parameterNames.has(parameterName)) {
+            invalidContract(`Operation '${name}' parameter name is invalid or duplicate.`);
+        }
+        parameterNames.add(parameterName);
+        const parameterType = normalizeCanonicalValueType(parameter.type, resourceNames, `operation '${name}' parameter '${parameterName}'`);
+        if (parameterType === null) {
+            invalidContract(`Operation '${name}' parameter '${parameterName}' type is outside the closed canonical value set.`);
+        }
+        parameters.push({ name: parameterName, type: parameterType });
+    }
+    const returnType = candidate.returnType == "void" ? "void" : normalizeCanonicalValueType(candidate.returnType, resourceNames, `operation '${name}' return type`);
+    if (returnType === null) {
+        invalidContract(`Operation '${name}' return type is outside the closed canonical value set.`);
+    }
+    const resourceFlow = validateContractResourceFlow(candidate.resourceFlow, parameters, failures, name);
+    const dependencies = validateOperationDependencies(candidate.dependencies);
+    const semantics = validateContractSemantics(candidate.semantics, name);
+    return deepFreeze({
+        dependencies,
+        effects: /** @type {const} */ (["host"]),
+        evaluationOrder: /** @type {const} */ ("left-to-right"),
+        failures,
+        name,
+        parameters,
+        resourceFlow,
+        returnType,
+        semantics
+    });
+}
+/**
+ * Validates one closed canonical value type spelling.
+ * @param {unknown} candidate - Candidate type.
+ * @param {Set<string>} resourceNames - Declared resource names.
+ * @param {string} _subject - Diagnostic subject reserved for caller context.
+ * @returns {string | CanonicalDeclarationReference | null} Detached type or null.
+ */
+function normalizeCanonicalValueType(candidate, resourceNames, _subject) {
+    if (typeof candidate == "string") {
+        if (scalarNames.has(candidate) || resourceNames.has(candidate))
+            return candidate;
+        const optional = /^optional:([a-z]+)$/u.exec(candidate);
+        return optional && scalarNames.has(optional[1]) ? candidate : null;
+    }
+    if (isPlainObject(candidate) && Object.keys(candidate).sort().join(",") == "module,name" &&
+        typeof candidate.module == "string" && identityPattern.test(candidate.module) && typeof candidate.name == "string" &&
+        declarationNamePattern.test(candidate.name))
+        return { module: candidate.module, name: candidate.name };
+    return null;
+}
+/**
+ * Validates one closed resource transition against its parameters and failures.
+ * @param {unknown} candidate - Candidate transition.
+ * @param {{name: string, type: string | CanonicalDeclarationReference}[]} parameters - Validated parameters.
+ * @param {(string | CanonicalDeclarationReference)[]} failures - Validated failure names.
+ * @param {string} operation - Operation name.
+ * @returns {object} Detached transition.
+ */
+function validateContractResourceFlow(candidate, parameters, failures, operation) {
+    if (!isPlainObject(candidate))
+        invalidContract(`Operation '${operation}' requires a resource flow declaration.`);
+    const ownedParameters = parameters.flatMap((parameter, index) => isOwnedCanonicalType(parameter.type) ? [index] : []);
+    if (Object.keys(candidate).sort().join(",") == "kind" && candidate.kind == "none") {
+        if (ownedParameters.length > 0)
+            invalidContract(`Operation '${operation}' owns a parameter without a transition.`);
+        return deepFreeze({ kind: /** @type {const} */ ("none") });
+    }
+    if (Object.keys(candidate).sort().join(",") == "kind,resource" && candidate.kind == "acquire") {
+        const resource = typeof candidate.resource == "string" && declarationNamePattern.test(candidate.resource)
+            ? candidate.resource
+            : normalizeCanonicalValueType(candidate.resource, new Set(), `operation '${operation}' acquisition`);
+        if (resource === null || ownedParameters.length > 0) {
+            invalidContract(`Operation '${operation}' acquisition flow is incomplete.`);
+        }
+        return deepFreeze({ kind: /** @type {const} */ ("acquire"), resource });
+    }
+    if (["borrow", "close"].includes(String(candidate.kind)) &&
+        Object.keys(candidate).sort().join(",") == "kind,parameterIndex,terminalFailure") {
+        const parameterIndex = /** @type {number} */ (candidate.parameterIndex);
+        if (!Number.isSafeInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= parameters.length ||
+            ownedParameters.length != 1 || ownedParameters[0] != parameterIndex ||
+            !failures.some((failure) => referenceKey(failure) == referenceKey(candidate.terminalFailure))) {
+            invalidContract(`Operation '${operation}' ${String(candidate.kind)} flow is incomplete.`);
+        }
+        return deepFreeze({ kind: /** @type {"borrow" | "close"} */ (candidate.kind), parameterIndex,
+            terminalFailure: normalizeFailureFlowReference(candidate.terminalFailure) });
+    }
+    return invalidContract(`Operation '${operation}' declares an unknown resource flow.`);
+}
+/**
+ * Validates one canonical operation dependency list.
+ * @param {unknown} candidate - Candidate dependencies.
+ * @returns {{module: string, operation: string, range: VersionRange}[]} Detached dependencies.
+ */
+function validateOperationDependencies(candidate) {
+    if (!isDenseArray(candidate))
+        invalidContract("Canonical contract dependencies must be a dense array.");
+    /** @type {{module: string, operation: string, range: VersionRange}[]} */
+    const dependencies = [];
+    for (const dependency of candidate) {
+        if (!isPlainObject(dependency))
+            invalidContract("Every canonical contract dependency must be a plain object.");
+        requireKeys(dependency, ["module", "operation", "range"], "contract dependency");
+        const module = /** @type {string} */ (dependency.module);
+        const operation = /** @type {string} */ (dependency.operation);
+        const range = parseStdlibVersionRange(dependency.range);
+        if (typeof module != "string" || !identityPattern.test(module) ||
+            typeof operation != "string" || !declarationNamePattern.test(operation) || range === null) {
+            invalidContract("Canonical contract dependency module, operation, or range is invalid.");
+        }
+        dependencies.push({ module, operation, range });
+    }
+    return dependencies;
+}
+/**
+ * Validates canonical operation dependencies against the complete registry identity set.
+ * @param {StdlibContractModule} record - Validated record.
+ * @param {Map<string, Map<string, StdlibContractModule>>} modules - All registered module versions.
+ * @returns {void}
+ */
+function validateContractDependencies(record, modules) {
+    const allowedDependencies = new Map(record.dependencies.map((dependency) => [dependency.module, dependency.range]));
+    for (const dependency of record.dependencies) {
+        const versions = modules.get(dependency.module);
+        if (!versions || ![...versions.keys()].some((version) => stdlibVersionSatisfies(/** @type {VersionTuple} */ (parseStdlibVersion(version)), dependency.range))) {
+            invalidContract(`Canonical module '${record.identity}' depends on missing or incompatible module '${dependency.module}'.`);
+        }
+    }
+    for (const operation of record.operations) {
+        for (const reference of operation.parameters.map(({ type }) => type).concat([operation.returnType]).filter(isDeclarationReference)) {
+            validateForeignDeclarationReference(record, reference, "resource", allowedDependencies, modules);
+        }
+        for (const reference of operation.failures.filter(isDeclarationReference)) {
+            validateForeignDeclarationReference(record, reference, "failure", allowedDependencies, modules);
+        }
+        for (const dependency of operation.dependencies) {
+            if (!modules.has(dependency.module)) {
+                invalidContract(`Operation '${operation.name}' depends on unknown canonical module '${dependency.module}'.`);
+            }
+            if (dependency.module == record.identity && dependency.operation == operation.name) {
+                invalidContract(`Operation '${operation.name}' declares a self-cycle dependency.`);
+            }
+        }
+    }
+}
+/**
+ * Validates declaration-only module dependencies.
+ * @param {unknown} candidate - Candidate dependency list.
+ * @param {string} identity - Owning module identity.
+ * @returns {{module: string, range: VersionRange}[]} Detached dependencies.
+ */
+function validateModuleDependencies(candidate, identity) {
+    if (!isDenseArray(candidate))
+        invalidContract("Canonical module dependencies must be a dense array.");
+    const names = new Set();
+    return candidate.map((dependency) => {
+        if (!isPlainObject(dependency))
+            invalidContract("Every canonical module dependency must be a plain object.");
+        requireKeys(dependency, ["module", "range"], "module dependency");
+        const module = /** @type {string} */ (dependency.module);
+        const range = parseStdlibVersionRange(dependency.range);
+        if (typeof module != "string" || !identityPattern.test(module) || module == identity || names.has(module) || range === null) {
+            invalidContract("Canonical module dependency is invalid, duplicate, self-referential, or malformed.");
+        }
+        names.add(module);
+        return { module, range };
+    });
+}
+/**
+ * Validates one dependency-qualified resource or failure reference.
+ * @param {StdlibContractModule} record - Owning module.
+ * @param {CanonicalDeclarationReference} reference - Qualified declaration.
+ * @param {"resource" | "failure"} kind - Declaration kind.
+ * @param {Map<string, VersionRange>} allowedDependencies - Direct dependency ranges.
+ * @param {Map<string, Map<string, StdlibContractModule>>} modules - Registry modules.
+ * @returns {void}
+ */
+function validateForeignDeclarationReference(record, reference, kind, allowedDependencies, modules) {
+    const range = allowedDependencies.get(reference.module);
+    if (!range)
+        invalidContract(`Canonical module '${record.identity}' uses undeclared dependency '${reference.module}'.`);
+    const versions = /** @type {Map<string, StdlibContractModule>} */ (modules.get(reference.module));
+    const matches = [...versions.values()].filter((module) => stdlibVersionSatisfies(/** @type {VersionTuple} */ (parseStdlibVersion(module.version)), range));
+    const declarations = kind == "resource" ? matches.flatMap(({ resources }) => resources) : matches.flatMap(({ failures }) => failures);
+    if (!declarations.some(({ name }) => name == reference.name)) {
+        invalidContract(`Canonical ${kind} '${reference.module}.${reference.name}' is not declared by a compatible dependency.`);
+    }
+}
+/**
+ * Normalizes one local or dependency-qualified declaration reference.
+ * @param {unknown} candidate - Candidate reference.
+ * @param {Set<string>} localNames - Declared local names.
+ * @param {string} subject - Diagnostic subject.
+ * @returns {string | CanonicalDeclarationReference} Detached reference.
+ */
+function normalizeDeclarationReference(candidate, localNames, subject) {
+    if (typeof candidate == "string" && localNames.has(candidate))
+        return candidate;
+    if (isDeclarationReference(candidate))
+        return { module: candidate.module, name: candidate.name };
+    return invalidContract(`${subject} is not a declared local or qualified canonical declaration.`);
+}
+/**
+ * Normalizes a terminal failure reference after membership validation.
+ * @param {unknown} candidate - Candidate failure reference.
+ * @returns {string | CanonicalDeclarationReference} Detached reference.
+ */
+function normalizeFailureFlowReference(candidate) {
+    if (typeof candidate == "string")
+        return candidate;
+    if (isDeclarationReference(candidate))
+        return { module: candidate.module, name: candidate.name };
+    return invalidContract("Resource flow terminal failure is invalid.");
+}
+/**
+ * Checks one canonical qualified declaration reference.
+ * @param {unknown} candidate - Candidate reference.
+ * @returns {candidate is CanonicalDeclarationReference} Whether the reference is exact.
+ */
+function isDeclarationReference(candidate) {
+    return isPlainObject(candidate) && Object.keys(candidate).sort().join(",") == "module,name" &&
+        typeof candidate.module == "string" && identityPattern.test(candidate.module) &&
+        typeof candidate.name == "string" && declarationNamePattern.test(candidate.name);
+}
+/**
+ * Encodes one declaration reference for equality checks.
+ * @param {unknown} candidate - Local or qualified reference.
+ * @returns {string} Stable equality key.
+ */
+function referenceKey(candidate) {
+    return typeof candidate == "string" ? `local:${candidate}` : isDeclarationReference(candidate)
+        ? `${candidate.module}:${candidate.name}` : `invalid:${String(candidate)}`;
+}
+/**
+ * Reports whether a canonical type denotes an owned resource.
+ * @param {string | CanonicalDeclarationReference} candidate - Canonical type.
+ * @returns {boolean} Whether the type is owned.
+ */
+function isOwnedCanonicalType(candidate) {
+    return isDeclarationReference(candidate) || (typeof candidate == "string" && !scalarNames.has(candidate) &&
+        !candidate.startsWith("optional:") && candidate != "void");
+}
+/**
+ * Validates one closed semantics declaration.
+ * @param {unknown} candidate - Candidate semantics.
+ * @param {string} operation - Operation name.
+ * @returns {Record<string, string>} Closed semantics fields.
+ */
+function validateContractSemantics(candidate, operation) {
+    if (!isPlainObject(candidate) || Object.keys(candidate).sort().join(",") !=
+        "blocking,close,encoding,eof,newline,ownership,timeout") {
+        invalidContract(`Operation '${operation}' requires the closed canonical semantics fields.`);
+    }
+    /** @type {Record<string, string>} */
+    const semantics = {};
+    for (const [field, allowed] of Object.entries(semanticsValues)) {
+        const value = /** @type {string} */ (candidate[field]);
+        if (typeof value != "string" || !allowed.has(value)) {
+            invalidContract(`Operation '${operation}' declares a non-canonical '${field}' semantics value.`);
+        }
+        semantics[field] = value;
+    }
+    return deepFreeze(semantics);
+}
+/**
+ * Validates one dense ordered single-field named declaration list.
+ * @param {unknown} candidate - Candidate list.
+ * @param {string} subject - Diagnostic subject.
+ * @returns {{name: string}[]} Detached declarations.
+ */
+function validateNamedList(candidate, subject) {
+    if (!isDenseArray(candidate))
+        invalidContract(`Canonical contract ${subject}s must be a dense array.`);
+    const names = new Set();
+    /** @type {{name: string}[]} */
+    const declarations = [];
+    for (const declaration of candidate) {
+        if (!isPlainObject(declaration) || Object.keys(declaration).join(",") != "name" ||
+            typeof declaration.name != "string" || !declarationNamePattern.test(declaration.name) || names.has(declaration.name)) {
+            invalidContract(`Canonical contract ${subject} declarations must be uniquely named.`);
+        }
+        names.add(/** @type {string} */ (declaration.name));
+        declarations.push({ name: /** @type {string} */ (declaration.name) });
+    }
+    return declarations;
+}
+/**
+ * Reports an unknown canonical module identity.
+ * @param {string} identity - Unknown identity.
+ * @returns {never} Always throws.
+ */
+function unknownModule(identity) {
+    throw new SemantifoldDiagnostic({ code: "STDLIB_MODULE_UNKNOWN", language: "stdlib",
+        message: `Standard-library module '${identity}' is not a registered canonical contract.` });
+}
+/**
+ * Reports one malformed version range.
+ * @returns {never} Always throws.
+ */
+function malformedRange() {
+    throw new SemantifoldDiagnostic({ code: "STDLIB_VERSION_MALFORMED", language: "stdlib",
+        message: "Standard-library version ranges use X, X.Y, or X.Y.Z without leading zeros or prerelease labels." });
+}
+/**
+ * Reports one unsatisfiable version range.
+ * @param {string} identity - Constrained module identity.
+ * @returns {never} Always throws.
+ */
+function incompatibleVersion(identity) {
+    throw new SemantifoldDiagnostic({ code: "STDLIB_VERSION_INCOMPATIBLE", language: "stdlib",
+        message: `No registered version of '${identity}' satisfies the declared standard-library version range.` });
+}
+/**
+ * Raises one stable canonical contract diagnostic.
+ * @param {string} message - Diagnostic message.
+ * @returns {never} Always throws.
+ */
+function invalidContract(message) {
+    throw new SemantifoldDiagnostic({ code: "STDLIB_CONTRACT_INVALID", language: "stdlib", message });
+}
+/**
+ * Requires one exact field set.
+ * @param {Record<string, unknown>} value - Candidate object.
+ * @param {string[]} keys - Required keys.
+ * @param {string} subject - Diagnostic subject.
+ * @returns {void}
+ */
+function requireKeys(value, keys, subject) {
+    if (Object.keys(value).sort().join(",") != [...keys].sort().join(","))
+        invalidContract(`Invalid ${subject} fields.`);
+}
+/**
+ * Checks an ordered dense array.
+ * @param {unknown} value - Candidate array.
+ * @returns {value is unknown[]} Whether the value is dense.
+ */
+function isDenseArray(value) {
+    return Array.isArray(value) && value.every((_item, index) => Object.hasOwn(value, index));
+}
+/**
+ * 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) {
+    return value !== null && typeof value == "object" && !Array.isArray(value) &&
+        Object.getPrototypeOf(value) == Object.prototype;
+}
+/**
+ * Recursively freezes a detached value.
+ * @template {object} Value
+ * @param {Value} value - Object to freeze.
+ * @returns {Readonly<Value>} Frozen object.
+ */
+function deepFreeze(value) {
+    for (const child of Object.values(value)) {
+        if (child && typeof child == "object" && !Object.isFrozen(child))
+            deepFreeze(child);
+    }
+    return Object.freeze(value);
+}
+/** @type {Readonly<StdlibContractRegistry>} */
+const builtinRegistry = createStdlibContractRegistry();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stdlib.js","sourceRoot":"","sources":["../../../src/semantic/stdlib.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,qBAAqB,EAAC,MAAM,kBAAkB,CAAA;AAEtD,MAAM,eAAe,GAAG,qBAAqB,CAAA;AAC7C,MAAM,sBAAsB,GAAG,2BAA2B,CAAA;AAC1D,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAA;AAC7D,MAAM,SAAS,GAAG,iBAAiB,CAAA;AACnC,MAAM,mBAAmB,GAAG,IAAI,MAAM,CAAC,IAAI,SAAS,MAAM,SAAS,MAAM,SAAS,GAAG,EAAE,GAAG,CAAC,CAAA;AAC3F,MAAM,YAAY,GAAG,IAAI,MAAM,CAAC,IAAI,SAAS,SAAS,SAAS,SAAS,EAAE,GAAG,CAAC,CAAA;AAC9E,MAAM,eAAe,GAAG;IACtB,QAAQ,EAAE,IAAI,GAAG,CAAC,CAAC,aAAa,CAAC,CAAC;IAClC,KAAK,EAAE,IAAI,GAAG,CAAC,CAAC,gBAAgB,EAAE,uBAAuB,EAAE,sBAAsB,CAAC,CAAC;IACnF,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,gBAAgB,EAAE,cAAc,CAAC,CAAC;IAChD,QAAQ,EAAE,IAAI,GAAG,CAAC,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;IAC9C,OAAO,EAAE,IAAI,GAAG,CAAC,CAAC,gBAAgB,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,sBAAsB,CAAC,CAAC;IAC/G,SAAS,EAAE,IAAI,GAAG,CAAC,CAAC,gBAAgB,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;IAC1E,OAAO,EAAE,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;CAC3B,CAAA;AAED,uDAAuD;AACvD,gFAAgF;AAChF,8EAA8E;AAC9E;;;;;;;;;;;GAWG;AACH;;;;;;;;GAQG;AACH;;;;;;;;;;GAUG;AACH;;;;GAIG;AAEH;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAK;IACtC,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IAC7E,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAA;IAC1E,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAA;AAC9B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAK;IAC3C,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IACtE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAA;IAC1D,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;IACtB,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC7C,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAE7C,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC;QAAE,OAAO,EAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAC,CAAA;IAC9E,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC;QAAE,OAAO,EAAC,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC,EAAC,CAAA;IACtF,OAAO,EAAC,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,EAAC,CAAA;AACzE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAI,EAAE,KAAK;IAC/C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QAC1C,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC7E,CAAC;IACD,OAAO,CAAC,CAAA;AACV,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS;IAC1D,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC;QACjE,OAAO,MAAM,IAAI,QAAQ,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,CAAC,OAAO,SAAS,IAAI,QAAQ;QACpF,CAAC,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QAAE,eAAe,CAAC,kDAAkD,CAAC,CAAA;IAClH,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,MAAM,CAAC;YAAE,eAAe,CAAC,+CAA+C,CAAC,CAAA;QAC1G,OAAO,0BAA0B,MAAM,IAAI,MAAM,EAAE,CAAA;IACrD,CAAC;IACD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,eAAe,CAAC,gDAAgD,CAAC,CAAA;IACpG,MAAM,aAAa,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IAEpH,OAAO,0BAA0B,MAAM,KAAK,aAAa,CAAC,MAAM,IAAI,aAAa,IAAI,SAAS,EAAE,CAAA;AAClG,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAI;IAC1C,MAAM,SAAS,GAAG,4FAA4F,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAEzH,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA;QAC1C,MAAM,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;QAE5B,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,aAAa,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAA;QACnH,IAAI,MAAM,GAAG,EAAE,CAAA;QAEf,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC;YAAE,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA;QAC3I,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;YAAE,OAAO,IAAI,CAAA;QAChH,OAAO,EAAC,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAC,CAAA;IAChE,CAAC;IACD,MAAM,KAAK,GAAG,kDAAkD,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC3E,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAA;IACvB,OAAO,EAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAC,CAAA;AAChD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,4BAA4B,CAAC,IAAI,EAAE,KAAK;IACtD,MAAM,KAAK,GAAG,qBAAqB,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAA;IAC5F,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnF,qBAAqB,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAA;IAEhF,IAAI,KAAK,KAAK,IAAI,IAAI,qBAAqB,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAA;IAC3E,OAAO,EAAC,KAAK,EAAE,KAAK,EAAC,CAAA;AACvB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAO,EAAE,KAAK;IACnD,IAAI,qBAAqB,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAA;IACjE,OAAO,KAAK,CAAC,KAAK,KAAK,IAAI,IAAI,qBAAqB,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;AAChF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAAC,OAAO,GAAG,gBAAgB,EAAE;IACvE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;QAAE,eAAe,CAAC,4DAA4D,CAAC,CAAA;IAEzG,6DAA6D;IAC7D,MAAM,OAAO,GAAG,IAAI,GAAG,EAAE,CAAA;IAEzB,KAAK,MAAM,SAAS,IAAI,OAAO,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,sBAAsB,CAAC,SAAS,CAAC,CAAA;QAChD,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,IAAI,GAAG,EAAE,CAAA;QAE1D,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC;YAAE,eAAe,CAAC,iCAAiC,MAAM,CAAC,QAAQ,cAAc,MAAM,CAAC,OAAO,IAAI,CAAC,CAAA;QACnI,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;QACpC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;IACxC,CAAC;IACD,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;QACtC,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE;YAAE,4BAA4B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACrF,CAAC;IACD,MAAM,aAAa,GAAG,CAAC,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;SACzC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC;QAC9B,QAAQ;QACR,QAAQ,EAAE,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,2BAA2B,CAAC,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC;aACvG,IAAI,CAAC,qBAAqB,CAAC;aAC3B,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;KAChE,CAAC,CAAC;SACF,GAAG,CAAC,UAAU,CAAC,CAAA;IAClB,MAAM,KAAK,GAAG,UAAU,CAAC,2FAA2F,CAAC,CAAC;QACpH,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC;KAChG,CAAC,CAAC,CAAA;IACH,OAAO,MAAM,CAAC,MAAM,CAAC,qCAAqC,CAAC,CAAC;QAC1D,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC;QACrC,aAAa,CAAC,QAAQ,EAAE,KAAK;YAC3B,OAAO,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAA;QACtD,CAAC;KACF,CAAC,CAAC,CAAA;AACL,CAAC;AAED;;;;;;GAMG;AACH,SAAS,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK;IACnD,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,SAAS,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAEhF,IAAI,CAAC,QAAQ;QAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACtC,MAAM,MAAM,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,2BAA2B,CAAC,CAAC,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAA;IAEnI,IAAI,CAAC,MAAM;QAAE,cAAc,EAAE,CAAA;IAC7B,uCAAuC;IACvC,IAAI,QAAQ,CAAA;IAEZ,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;QACtC,MAAM,KAAK,GAAG,2BAA2B,CAAC,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAA;QAEvE,IAAI,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,KAAK,SAAS,IAAI,qBAAqB,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YACpH,QAAQ,GAAG,KAAK,CAAA;QAClB,CAAC;IACH,CAAC;IACD,IAAI,QAAQ,KAAK,SAAS;QAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAA;IACzD,MAAM,MAAM,GAAG,6CAA6C,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IAE3H,OAAO,UAAU,CAAC;QAChB,YAAY,EAAE,MAAM,CAAC,YAAY;QACjC,QAAQ,EAAE,MAAM,CAAC,QAAQ;QACzB,QAAQ,EAAE,MAAM,CAAC,QAAQ;QACzB,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,MAAM,EAAE,oBAAoB,CAAC,CAAC,2BAA2B,CAAC;QAC1D,aAAa,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC;QACvC,OAAO,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE;KACxD,CAAC,CAAA;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,eAAe,CAAC,OAAO,CAAA;AAChC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAQ,EAAE,KAAK;IACjD,OAAO,eAAe,CAAC,aAAa,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;AACvD,CAAC;AAED;;;GAGG;AACH,SAAS,oBAAoB;IAC3B,OAAO;QACL,YAAY,EAAE,EAAE;QAChB,QAAQ,EAAE;YACR,EAAC,IAAI,EAAE,uBAAuB,EAAC;YAC/B,EAAC,IAAI,EAAE,qBAAqB,EAAC;YAC7B,EAAC,IAAI,EAAE,kBAAkB,EAAC;YAC1B,EAAC,IAAI,EAAE,mBAAmB,EAAC;YAC3B,EAAC,IAAI,EAAE,qBAAqB,EAAC;SAC9B;QACD,QAAQ,EAAE,oCAAoC;QAC9C,UAAU,EAAE;YACV;gBACE,YAAY,EAAE,EAAE;gBAChB,OAAO,EAAE,CAAC,MAAM,CAAC;gBACjB,eAAe,EAAE,eAAe;gBAChC,QAAQ,EAAE,CAAC,uBAAuB,CAAC;gBACnC,IAAI,EAAE,aAAa;gBACnB,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAC,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAC,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC;gBAChH,YAAY,EAAE,EAAC,IAAI,EAAE,MAAM,EAAC;gBAC5B,UAAU,EAAE,SAAS;gBACrB,SAAS,EAAE,kBAAkB,EAAE;aAChC;YACD;gBACE,YAAY,EAAE,EAAE;gBAChB,OAAO,EAAE,CAAC,MAAM,CAAC;gBACjB,eAAe,EAAE,eAAe;gBAChC,QAAQ,EAAE,CAAC,qBAAqB,CAAC;gBACjC,IAAI,EAAE,cAAc;gBACpB,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC;gBAC7C,YAAY,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,eAAe,EAAC;gBAC1D,UAAU,EAAE,eAAe;gBAC3B,SAAS,EAAE,kBAAkB,CAAC,EAAC,SAAS,EAAE,UAAU,EAAC,CAAC;aACvD;YACD;gBACE,YAAY,EAAE,EAAE;gBAChB,OAAO,EAAE,CAAC,MAAM,CAAC;gBACjB,eAAe,EAAE,eAAe;gBAChC,QAAQ,EAAE,CAAC,kBAAkB,EAAE,qBAAqB,CAAC;gBACrD,IAAI,EAAE,WAAW;gBACjB,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,EAAC,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC;gBACxF,YAAY,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,EAAE,eAAe,EAAE,qBAAqB,EAAC;gBACzF,UAAU,EAAE,iBAAiB;gBAC7B,SAAS,EAAE,kBAAkB,CAAC;oBAC5B,KAAK,EAAE,uBAAuB;oBAC9B,GAAG,EAAE,cAAc;oBACnB,QAAQ,EAAE,OAAO;oBACjB,OAAO,EAAE,uBAAuB;oBAChC,SAAS,EAAE,UAAU;iBACtB,CAAC;aACH;YACD;gBACE,YAAY,EAAE,EAAE;gBAChB,OAAO,EAAE,CAAC,MAAM,CAAC;gBACjB,eAAe,EAAE,eAAe;gBAChC,QAAQ,EAAE,CAAC,mBAAmB,EAAE,qBAAqB,CAAC;gBACtD,IAAI,EAAE,YAAY;gBAClB,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,EAAC,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC;gBACxF,YAAY,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,EAAE,eAAe,EAAE,qBAAqB,EAAC;gBACxF,UAAU,EAAE,MAAM;gBAClB,SAAS,EAAE,kBAAkB,CAAC,EAAC,KAAK,EAAE,sBAAsB,EAAE,SAAS,EAAE,UAAU,EAAC,CAAC;aACtF;YACD;gBACE,YAAY,EAAE,EAAE;gBAChB,OAAO,EAAE,CAAC,MAAM,CAAC;gBACjB,eAAe,EAAE,eAAe;gBAChC,QAAQ,EAAE,EAAE;gBACZ,IAAI,EAAE,YAAY;gBAClB,UAAU,EAAE,EAAE;gBACd,YAAY,EAAE,EAAC,IAAI,EAAE,MAAM,EAAC;gBAC5B,UAAU,EAAE,QAAQ;gBACpB,SAAS,EAAE,kBAAkB,EAAE;aAChC;SACF;QACD,SAAS,EAAE,CAAC,EAAC,IAAI,EAAE,eAAe,EAAC,CAAC;QACpC,OAAO,EAAE,OAAO;KACjB,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,gBAAgB;IACvB,OAAO,CAAC,oBAAoB,EAAE,EAAE,2BAA2B,EAAE,EAAE,yBAAyB,EAAE;QACxF,qBAAqB,EAAE,EAAE,uBAAuB,EAAE,CAAC,CAAA;AACvD,CAAC;AAED;;;GAGG;AACH,SAAS,2BAA2B;IAClC,MAAM,UAAU,GAAG,EAAC,MAAM,EAAE,sBAAsB,EAAE,IAAI,EAAE,YAAY,EAAC,CAAA;IAEvE,OAAO;QACL,YAAY,EAAE,CAAC,EAAC,MAAM,EAAE,sBAAsB,EAAE,KAAK,EAAE,GAAG,EAAC,CAAC;QAC5D,QAAQ,EAAE,CAAC,EAAC,IAAI,EAAE,aAAa,EAAC,EAAE,EAAC,IAAI,EAAE,aAAa,EAAC,EAAE,EAAC,IAAI,EAAE,mBAAmB,EAAC,CAAC;QACrF,QAAQ,EAAE,2BAA2B;QACrC,UAAU,EAAE,CAAC;gBACX,YAAY,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,eAAe;gBACrE,QAAQ,EAAE,CAAC,aAAa,EAAE,aAAa,EAAE,mBAAmB,CAAC,EAAE,IAAI,EAAE,YAAY;gBACjF,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAC,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC;gBAC7E,YAAY,EAAE,EAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAC,EAAE,UAAU,EAAE,UAAU;gBAC7E,SAAS,EAAE,kBAAkB,CAAC,EAAC,SAAS,EAAE,UAAU,EAAC,CAAC;aACvD,CAAC;QACF,SAAS,EAAE,EAAE;QACb,OAAO,EAAE,OAAO;KACjB,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,yBAAyB;IAChC,MAAM,UAAU,GAAG,EAAC,MAAM,EAAE,sBAAsB,EAAE,IAAI,EAAE,YAAY,EAAC,CAAA;IACvE,MAAM,cAAc,GAAG,EAAC,MAAM,EAAE,sBAAsB,EAAE,IAAI,EAAE,gBAAgB,EAAC,CAAA;IAE/E,OAAO;QACL,YAAY,EAAE,CAAC,EAAC,MAAM,EAAE,sBAAsB,EAAE,KAAK,EAAE,GAAG,EAAC,CAAC;QAC5D,QAAQ,EAAE,CAAC,EAAC,IAAI,EAAE,aAAa,EAAC,EAAE,EAAC,IAAI,EAAE,eAAe,EAAC,CAAC;QAC1D,QAAQ,EAAE,yBAAyB;QACnC,UAAU,EAAE,CAAC;gBACX,YAAY,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,eAAe;gBACrE,QAAQ,EAAE,CAAC,aAAa,EAAE,eAAe,EAAE,cAAc,CAAC,EAAE,IAAI,EAAE,cAAc;gBAChF,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAC,CAAC;gBAClD,YAAY,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,EAAE,eAAe,EAAE,cAAc,EAAC;gBAClF,UAAU,EAAE,iBAAiB;gBAC7B,SAAS,EAAE,kBAAkB,CAAC,EAAC,KAAK,EAAE,uBAAuB,EAAE,GAAG,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO;oBACnG,OAAO,EAAE,wBAAwB,EAAE,SAAS,EAAE,UAAU,EAAC,CAAC;aAC7D,CAAC;QACF,SAAS,EAAE,EAAE;QACb,OAAO,EAAE,OAAO;KACjB,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,qBAAqB;IAC5B,OAAO;QACL,YAAY,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAC,IAAI,EAAE,cAAc,EAAC,CAAC,EAAE,QAAQ,EAAE,oBAAoB;QACpF,UAAU,EAAE,CAAC;gBACX,YAAY,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC,cAAc,CAAC;gBACjG,IAAI,EAAE,eAAe,EAAE,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAC,CAAC,EAAE,YAAY,EAAE,EAAC,IAAI,EAAE,MAAM,EAAC;gBACjG,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB,CAAC,EAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,sBAAsB,EAAC,CAAC;aACxG,CAAC;QACF,SAAS,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO;KAChC,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,uBAAuB;IAC9B,OAAO;QACL,YAAY,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAC,IAAI,EAAE,cAAc,EAAC,EAAE,EAAC,IAAI,EAAE,gBAAgB,EAAC,CAAC,EAAE,QAAQ,EAAE,sBAAsB;QAChH,UAAU,EAAE,CAAC;gBACX,YAAY,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,eAAe;gBACrE,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC,EAAE,IAAI,EAAE,UAAU;gBAC9D,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,YAAY,EAAC,CAAC;gBACpD,YAAY,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,EAAE,eAAe,EAAE,gBAAgB,EAAC,EAAE,UAAU,EAAE,MAAM;gBACvG,SAAS,EAAE,kBAAkB,CAAC,EAAC,KAAK,EAAE,sBAAsB,EAAE,SAAS,EAAE,UAAU,EAAC,CAAC;aACtF,CAAC;QACF,SAAS,EAAE,CAAC,EAAC,IAAI,EAAE,YAAY,EAAC,CAAC,EAAE,OAAO,EAAE,OAAO;KACpD,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,SAAS,GAAG,EAAE;IACxC,OAAO;QACL,QAAQ,EAAE,aAAa;QACvB,KAAK,EAAE,gBAAgB;QACvB,GAAG,EAAE,gBAAgB;QACrB,QAAQ,EAAE,gBAAgB;QAC1B,OAAO,EAAE,gBAAgB;QACzB,SAAS,EAAE,gBAAgB;QAC3B,OAAO,EAAE,MAAM;QACf,GAAG,SAAS;KACb,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,sBAAsB,CAAC,SAAS;IACvC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;QAAE,eAAe,CAAC,yDAAyD,CAAC,CAAA;IACzG,WAAW,CAAC,SAAS,EAAE,CAAC,cAAc,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,iBAAiB,CAAC,CAAA;IACzH,MAAM,QAAQ,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAA;IAE3D,IAAI,OAAO,QAAQ,IAAI,QAAQ,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC;QAAE,eAAe,CAAC,yCAAyC,CAAC,CAAA;IAC9H,MAAM,OAAO,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;IAEzD,IAAI,kBAAkB,CAAC,OAAO,CAAC,KAAK,IAAI;QAAE,eAAe,CAAC,+BAA+B,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;IACxH,MAAM,SAAS,GAAG,iBAAiB,CAAC,SAAS,CAAC,SAAS,EAAE,UAAU,CAAC,CAAA;IACpE,MAAM,QAAQ,GAAG,iBAAiB,CAAC,SAAS,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAA;IACjE,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAC9D,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAC5D,MAAM,cAAc,GAAG,IAAI,GAAG,EAAE,CAAA;IAChC,MAAM,YAAY,GAAG,0BAA0B,CAAC,SAAS,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAA;IAEjF,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,UAAU,CAAC;QAAE,eAAe,CAAC,sDAAsD,CAAC,CAAA;IAChH,MAAM,UAAU,GAAG,wBAAwB,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CACnF,yBAAyB,CAAC,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC,CAAA;IAEpF,OAAO,UAAU,CAAC;QAChB,YAAY;QACZ,QAAQ;QACR,QAAQ;QACR,UAAU;QACV,SAAS;QACT,OAAO,EAAE,qBAAqB,CAAC,CAAC,OAAO,CAAC;KACzC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,yBAAyB,CAAC,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc;IACvF,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;QAAE,eAAe,CAAC,4DAA4D,CAAC,CAAA;IAC5G,WAAW,CAAC,SAAS,EAAE,CAAC,cAAc,EAAE,SAAS,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,WAAW,CAAC,EAAE,oBAAoB,CAAC,CAAA;IACzK,MAAM,IAAI,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;IAEnD,IAAI,OAAO,IAAI,IAAI,QAAQ,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC9F,eAAe,CAAC,4DAA4D,CAAC,CAAA;IAC/E,CAAC;IACD,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IACxB,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,SAAS,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,MAAM,EAAE,CAAC;QACxG,eAAe,CAAC,cAAc,IAAI,gDAAgD,CAAC,CAAA;IACrF,CAAC;IACD,IAAI,SAAS,CAAC,eAAe,IAAI,eAAe;QAAE,eAAe,CAAC,cAAc,IAAI,sCAAsC,CAAC,CAAA;IAC3H,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;QACtC,eAAe,CAAC,cAAc,IAAI,2CAA2C,CAAC,CAAA;IAChF,CAAC;IACD,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,6BAA6B,CAAC,OAAO,EAAE,YAAY,EAAE,cAAc,IAAI,WAAW,CAAC,CAAC,CAAA;IACzI,IAAI,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,IAAI,QAAQ,CAAC,MAAM;QAAE,eAAe,CAAC,cAAc,IAAI,+BAA+B,CAAC,CAAA;IACnI,MAAM,cAAc,GAAG,IAAI,GAAG,EAAE,CAAA;IAChC,6EAA6E;IAC7E,MAAM,UAAU,GAAG,EAAE,CAAA;IAErB,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,UAAU,CAAC;QAAE,eAAe,CAAC,cAAc,IAAI,qCAAqC,CAAC,CAAA;IACjH,KAAK,MAAM,SAAS,IAAI,wBAAwB,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;QACxE,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;YAAE,eAAe,CAAC,cAAc,IAAI,qCAAqC,CAAC,CAAA;QACvG,WAAW,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,IAAI,aAAa,CAAC,CAAA;QACzE,MAAM,aAAa,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;QAE5D,IAAI,OAAO,aAAa,IAAI,QAAQ,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC;YACzH,eAAe,CAAC,cAAc,IAAI,2CAA2C,CAAC,CAAA;QAChF,CAAC;QACD,cAAc,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;QACjC,MAAM,aAAa,GAAG,2BAA2B,CAAC,SAAS,CAAC,IAAI,EAAE,aAAa,EAAE,cAAc,IAAI,gBAAgB,aAAa,GAAG,CAAC,CAAA;QAEpI,IAAI,aAAa,KAAK,IAAI,EAAE,CAAC;YAC3B,eAAe,CAAC,cAAc,IAAI,gBAAgB,aAAa,mDAAmD,CAAC,CAAA;QACrH,CAAC;QACD,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,EAAC,CAAC,CAAA;IAC7D,CAAC;IACD,MAAM,UAAU,GAAG,SAAS,CAAC,UAAU,IAAI,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,2BAA2B,CAAC,SAAS,CAAC,UAAU,EAAE,aAAa,EAAE,cAAc,IAAI,eAAe,CAAC,CAAA;IAEhK,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QACxB,eAAe,CAAC,cAAc,IAAI,0DAA0D,CAAC,CAAA;IAC/F,CAAC;IACD,MAAM,YAAY,GAAG,4BAA4B,CAAC,SAAS,CAAC,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAA;IACrG,MAAM,YAAY,GAAG,6BAA6B,CAAC,SAAS,CAAC,YAAY,CAAC,CAAA;IAC1E,MAAM,SAAS,GAAG,yBAAyB,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,CAAC,CAAA;IAEtE,OAAO,UAAU,CAAC;QAChB,YAAY;QACZ,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACxC,eAAe,EAAE,oBAAoB,CAAC,CAAC,eAAe,CAAC;QACvD,QAAQ;QACR,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,UAAU;QACV,SAAS;KACV,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,2BAA2B,CAAC,SAAS,EAAE,aAAa,EAAE,QAAQ;IACrE,IAAI,OAAO,SAAS,IAAI,QAAQ,EAAE,CAAC;QACjC,IAAI,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,OAAO,SAAS,CAAA;QAChF,MAAM,QAAQ,GAAG,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QAEvD,OAAO,QAAQ,IAAI,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAA;IACpE,CAAC;IACD,IAAI,aAAa,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,aAAa;QACtF,OAAO,SAAS,CAAC,MAAM,IAAI,QAAQ,IAAI,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,OAAO,SAAS,CAAC,IAAI,IAAI,QAAQ;QAClH,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;QAAE,OAAO,EAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAC,CAAA;IACtG,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,4BAA4B,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS;IAC9E,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;QAAE,eAAe,CAAC,cAAc,SAAS,yCAAyC,CAAC,CAAA;IAChH,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC,oBAAoB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;IAErH,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,MAAM,IAAI,SAAS,CAAC,IAAI,IAAI,MAAM,EAAE,CAAC;QAClF,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC;YAAE,eAAe,CAAC,cAAc,SAAS,0CAA0C,CAAC,CAAA;QAClH,OAAO,UAAU,CAAC,EAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,MAAM,CAAC,EAAC,CAAC,CAAA;IAC1D,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,eAAe,IAAI,SAAS,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC;QAC9F,MAAM,QAAQ,GAAG,OAAO,SAAS,CAAC,QAAQ,IAAI,QAAQ,IAAI,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;YACvG,CAAC,CAAC,SAAS,CAAC,QAAQ;YACpB,CAAC,CAAC,2BAA2B,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,GAAG,EAAE,EAAE,cAAc,SAAS,eAAe,CAAC,CAAA;QACtG,IAAI,QAAQ,KAAK,IAAI,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpD,eAAe,CAAC,cAAc,SAAS,mCAAmC,CAAC,CAAA;QAC7E,CAAC;QACD,OAAO,UAAU,CAAC,EAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAC,CAAC,CAAA;IACvE,CAAC;IACD,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACtD,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,qCAAqC,EAAE,CAAC;QACnF,MAAM,cAAc,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;QAEvE,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,cAAc,CAAC,IAAI,cAAc,GAAG,CAAC,IAAI,cAAc,IAAI,UAAU,CAAC,MAAM;YACpG,eAAe,CAAC,MAAM,IAAI,CAAC,IAAI,eAAe,CAAC,CAAC,CAAC,IAAI,cAAc;YACnE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,YAAY,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC;YAChG,eAAe,CAAC,cAAc,SAAS,KAAK,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAA;QAC3F,CAAC;QACD,OAAO,UAAU,CAAC,EAAC,IAAI,EAAE,iCAAiC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,cAAc;YACzF,eAAe,EAAE,6BAA6B,CAAC,SAAS,CAAC,eAAe,CAAC,EAAC,CAAC,CAAA;IAC/E,CAAC;IACD,OAAO,eAAe,CAAC,cAAc,SAAS,sCAAsC,CAAC,CAAA;AACvF,CAAC;AAED;;;;GAIG;AACH,SAAS,6BAA6B,CAAC,SAAS;IAC9C,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QAAE,eAAe,CAAC,wDAAwD,CAAC,CAAA;IACvG,yEAAyE;IACzE,MAAM,YAAY,GAAG,EAAE,CAAA;IAEvB,KAAK,MAAM,UAAU,IAAI,SAAS,EAAE,CAAC;QACnC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC;YAAE,eAAe,CAAC,6DAA6D,CAAC,CAAA;QAC9G,WAAW,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,qBAAqB,CAAC,CAAA;QAChF,MAAM,MAAM,GAAG,qBAAqB,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;QACxD,MAAM,SAAS,GAAG,qBAAqB,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,CAAA;QAC9D,MAAM,KAAK,GAAG,uBAAuB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;QAEvD,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC;YAC5D,OAAO,SAAS,IAAI,QAAQ,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YAC5F,eAAe,CAAC,uEAAuE,CAAC,CAAA;QAC1F,CAAC;QACD,YAAY,CAAC,IAAI,CAAC,EAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAC,CAAC,CAAA;IAC/C,CAAC;IACD,OAAO,YAAY,CAAA;AACrB,CAAC;AAED;;;;;GAKG;AACH,SAAS,4BAA4B,CAAC,MAAM,EAAE,OAAO;IACnD,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IAEnH,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;QAC7C,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;QAE/C,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,sBAAsB,CAAC,2BAA2B,CAAC,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;YAC9J,eAAe,CAAC,qBAAqB,MAAM,CAAC,QAAQ,gDAAgD,UAAU,CAAC,MAAM,IAAI,CAAC,CAAA;QAC5H,CAAC;IACH,CAAC;IACD,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;QAC1C,KAAK,MAAM,SAAS,IAAI,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,sBAAsB,CAAC,EAAE,CAAC;YACjI,mCAAmC,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,mBAAmB,EAAE,OAAO,CAAC,CAAA;QAClG,CAAC;QACD,KAAK,MAAM,SAAS,IAAI,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,sBAAsB,CAAC,EAAE,CAAC;YAC1E,mCAAmC,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,mBAAmB,EAAE,OAAO,CAAC,CAAA;QACjG,CAAC;QACD,KAAK,MAAM,UAAU,IAAI,SAAS,CAAC,YAAY,EAAE,CAAC;YAChD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;gBACpC,eAAe,CAAC,cAAc,SAAS,CAAC,IAAI,0CAA0C,UAAU,CAAC,MAAM,IAAI,CAAC,CAAA;YAC9G,CAAC;YACD,IAAI,UAAU,CAAC,MAAM,IAAI,MAAM,CAAC,QAAQ,IAAI,UAAU,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC;gBACnF,eAAe,CAAC,cAAc,SAAS,CAAC,IAAI,qCAAqC,CAAC,CAAA;YACpF,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,0BAA0B,CAAC,SAAS,EAAE,QAAQ;IACrD,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QAAE,eAAe,CAAC,sDAAsD,CAAC,CAAA;IACrG,MAAM,KAAK,GAAG,IAAI,GAAG,EAAE,CAAA;IAEvB,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE;QAClC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC;YAAE,eAAe,CAAC,2DAA2D,CAAC,CAAA;QAC5G,WAAW,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,mBAAmB,CAAC,CAAA;QACjE,MAAM,MAAM,GAAG,qBAAqB,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;QACxD,MAAM,KAAK,GAAG,uBAAuB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;QAEvD,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,QAAQ,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YAC5H,eAAe,CAAC,oFAAoF,CAAC,CAAA;QACvG,CAAC;QACD,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QACjB,OAAO,EAAC,MAAM,EAAE,KAAK,EAAC,CAAA;IACxB,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,mCAAmC,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,mBAAmB,EAAE,OAAO;IAChG,MAAM,KAAK,GAAG,mBAAmB,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;IAEvD,IAAI,CAAC,KAAK;QAAE,eAAe,CAAC,qBAAqB,MAAM,CAAC,QAAQ,iCAAiC,SAAS,CAAC,MAAM,IAAI,CAAC,CAAA;IACtH,MAAM,QAAQ,GAAG,gDAAgD,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAA;IACjG,MAAM,OAAO,GAAG,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CACvD,sBAAsB,CAAC,2BAA2B,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAA;IAClG,MAAM,YAAY,GAAG,IAAI,IAAI,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,EAAC,SAAS,EAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,EAAC,QAAQ,EAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAA;IAEjI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3D,eAAe,CAAC,aAAa,IAAI,KAAK,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,IAAI,+CAA+C,CAAC,CAAA;IAC1H,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,6BAA6B,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO;IACnE,IAAI,OAAO,SAAS,IAAI,QAAQ,IAAI,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC;QAAE,OAAO,SAAS,CAAA;IAC/E,IAAI,sBAAsB,CAAC,SAAS,CAAC;QAAE,OAAO,EAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAC,CAAA;IAC9F,OAAO,eAAe,CAAC,GAAG,OAAO,8DAA8D,CAAC,CAAA;AAClG,CAAC;AAED;;;;GAIG;AACH,SAAS,6BAA6B,CAAC,SAAS;IAC9C,IAAI,OAAO,SAAS,IAAI,QAAQ;QAAE,OAAO,SAAS,CAAA;IAClD,IAAI,sBAAsB,CAAC,SAAS,CAAC;QAAE,OAAO,EAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAC,CAAA;IAC9F,OAAO,eAAe,CAAC,4CAA4C,CAAC,CAAA;AACtE,CAAC;AAED;;;;GAIG;AACH,SAAS,sBAAsB,CAAC,SAAS;IACvC,OAAO,aAAa,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,aAAa;QACzF,OAAO,SAAS,CAAC,MAAM,IAAI,QAAQ,IAAI,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;QAC7E,OAAO,SAAS,CAAC,IAAI,IAAI,QAAQ,IAAI,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;AACpF,CAAC;AAED;;;;GAIG;AACH,SAAS,YAAY,CAAC,SAAS;IAC7B,OAAO,OAAO,SAAS,IAAI,QAAQ,CAAC,CAAC,CAAC,SAAS,SAAS,EAAE,CAAC,CAAC,CAAC,sBAAsB,CAAC,SAAS,CAAC;QAC5F,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,WAAW,MAAM,CAAC,SAAS,CAAC,EAAE,CAAA;AAC9E,CAAC;AAED;;;;GAIG;AACH,SAAS,oBAAoB,CAAC,SAAS;IACrC,OAAO,sBAAsB,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,SAAS,IAAI,QAAQ,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC;QACtG,CAAC,SAAS,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,SAAS,IAAI,MAAM,CAAC,CAAA;AAC9D,CAAC;AAED;;;;;GAKG;AACH,SAAS,yBAAyB,CAAC,SAAS,EAAE,SAAS;IACrD,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;QACtE,uDAAuD,EAAE,CAAC;QAC1D,eAAe,CAAC,cAAc,SAAS,mDAAmD,CAAC,CAAA;IAC7F,CAAC;IACD,qCAAqC;IACrC,MAAM,SAAS,GAAG,EAAE,CAAA;IAEpB,KAAK,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC;QAC/D,MAAM,KAAK,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAA;QAEtD,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACpD,eAAe,CAAC,cAAc,SAAS,+BAA+B,KAAK,oBAAoB,CAAC,CAAA;QAClG,CAAC;QACD,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,CAAA;IAC1B,CAAC;IACD,OAAO,UAAU,CAAC,SAAS,CAAC,CAAA;AAC9B,CAAC;AAED;;;;;GAKG;AACH,SAAS,iBAAiB,CAAC,SAAS,EAAE,OAAO;IAC3C,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QAAE,eAAe,CAAC,sBAAsB,OAAO,0BAA0B,CAAC,CAAA;IACtG,MAAM,KAAK,GAAG,IAAI,GAAG,EAAE,CAAA;IACvB,+BAA+B;IAC/B,MAAM,YAAY,GAAG,EAAE,CAAA;IAEvB,KAAK,MAAM,WAAW,IAAI,SAAS,EAAE,CAAC;QACpC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,MAAM;YAC7E,OAAO,WAAW,CAAC,IAAI,IAAI,QAAQ,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;YACvH,eAAe,CAAC,sBAAsB,OAAO,uCAAuC,CAAC,CAAA;QACvF,CAAC;QACD,KAAK,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAA;QACnD,YAAY,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,EAAC,CAAC,CAAA;IACrE,CAAC;IACD,OAAO,YAAY,CAAA;AACrB,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,QAAQ;IAC7B,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,uBAAuB,EAAE,QAAQ,EAAE,QAAQ;QAChF,OAAO,EAAE,4BAA4B,QAAQ,2CAA2C,EAAC,CAAC,CAAA;AAC9F,CAAC;AAED;;;GAGG;AACH,SAAS,cAAc;IACrB,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,0BAA0B,EAAE,QAAQ,EAAE,QAAQ;QACnF,OAAO,EAAE,kGAAkG,EAAC,CAAC,CAAA;AACjH,CAAC;AAED;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,QAAQ;IACnC,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,6BAA6B,EAAE,QAAQ,EAAE,QAAQ;QACtF,OAAO,EAAE,6BAA6B,QAAQ,0DAA0D,EAAC,CAAC,CAAA;AAC9G,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,OAAO;IAC9B,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,yBAAyB,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAC,CAAC,CAAA;AACjG,CAAC;AAED;;;;;;GAMG;AACH,SAAS,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO;IACvC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,eAAe,CAAC,WAAW,OAAO,UAAU,CAAC,CAAA;AACtH,CAAC;AAED;;;;GAIG;AACH,SAAS,YAAY,CAAC,KAAK;IACzB,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;AAC3F,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,KAAK;IAC1B,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACxE,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,SAAS,CAAA;AACpD,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAAC,KAAK;IACvB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACzC,IAAI,KAAK,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,UAAU,CAAC,KAAK,CAAC,CAAA;IACrF,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AAC7B,CAAC;AAED,+CAA+C;AAC/C,MAAM,eAAe,GAAG,4BAA4B,EAAE,CAAA","sourcesContent":["// @ts-check\n\nimport {SemantifoldDiagnostic} from \"../diagnostic.js\"\n\nconst identityPattern = /^[a-z][a-z0-9.-]*$/u\nconst declarationNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/u\nconst scalarNames = new Set([\"boolean\", \"integer\", \"string\"])\nconst component = \"(0|[1-9][0-9]*)\"\nconst exactVersionPattern = new RegExp(`^${component}\\\\.${component}\\\\.${component}$`, \"u\")\nconst rangePattern = new RegExp(`^${component}(?:\\\\.${component}){0,2}$`, \"u\")\nconst semanticsValues = {\n  blocking: new Set([\"synchronous\"]),\n  close: new Set([\"not-applicable\", \"use-after-close-fails\", \"repeated-close-fails\"]),\n  eof: new Set([\"not-applicable\", \"absent-value\"]),\n  encoding: new Set([\"not-applicable\", \"utf-8\"]),\n  newline: new Set([\"not-applicable\", \"strip-line-terminator\", \"retain-line-terminator\", \"append-lf-if-missing\"]),\n  ownership: new Set([\"not-applicable\", \"acquired\", \"borrowed\", \"consumed\"]),\n  timeout: new Set([\"none\"])\n}\n\n/** @typedef {[number, number, number]} VersionTuple */\n/** @typedef {{lower: VersionTuple, upper: VersionTuple | null}} VersionRange */\n/** @typedef {{module: string, name: string}} CanonicalDeclarationReference */\n/**\n * @typedef StdlibContractOperation\n * @property {{module: string, operation: string, range: VersionRange}[]} dependencies - Canonical operation dependencies.\n * @property {[\"host\"]} effects - Closed effect declaration.\n * @property {\"left-to-right\"} evaluationOrder - Canonical argument evaluation order.\n * @property {(string | CanonicalDeclarationReference)[]} failures - Declared failure names.\n * @property {string} name - Operation name.\n * @property {{name: string, type: string | CanonicalDeclarationReference}[]} parameters - Ordered parameters.\n * @property {object} resourceFlow - Closed resource transition.\n * @property {string | CanonicalDeclarationReference} returnType - Closed return type spelling.\n * @property {Record<string, string>} semantics - Closed canonical semantics fields.\n */\n/**\n * @typedef StdlibContractModule\n * @property {{module: string, range: VersionRange}[]} dependencies - Versioned declaration dependencies.\n * @property {{name: string}[]} failures - Ordered failure declarations.\n * @property {string} identity - Canonical module identity.\n * @property {StdlibContractOperation[]} operations - Ordered operation declarations.\n * @property {{name: string}[]} resources - Ordered resource declarations.\n * @property {string} version - Exact registered version.\n */\n/**\n * @typedef StdlibContract\n * @property {{module: string, range: VersionRange}[]} dependencies - Versioned declaration dependencies.\n * @property {{name: string}[]} failures - Ordered failure declarations.\n * @property {string} identity - Canonical module identity.\n * @property {StdlibContractOperation[]} operations - Ordered operation declarations.\n * @property {{name: string}[]} resources - Ordered resource declarations.\n * @property {\"SemantifoldStdlibContract\"} schema - Contract schema discriminator.\n * @property {1} schemaVersion - Contract schema version.\n * @property {string} version - Resolved exact version.\n */\n/**\n * @typedef StdlibContractRegistry\n * @property {{identity: string, versions: string[]}[]} modules - Registered modules in stable order.\n * @property {(identity: string, range?: string) => StdlibContract} resolveModule - Versioned module resolution.\n */\n\n/**\n * Parses one exact X.Y.Z standard-library version.\n * @param {unknown} value - Candidate version.\n * @returns {VersionTuple | null} Parsed version or null when malformed.\n */\nexport function parseStdlibVersion(value) {\n  if (typeof value != \"string\" || !exactVersionPattern.test(value)) return null\n  const [major, minor, patch] = value.split(\".\").map((part) => Number(part))\n  return [major, minor, patch]\n}\n\n/**\n * Parses one X, X.Y, or X.Y.Z standard-library version range.\n * @param {unknown} value - Candidate range.\n * @returns {VersionRange | null} Half-open range or null when malformed.\n */\nexport function parseStdlibVersionRange(value) {\n  if (typeof value != \"string\" || !rangePattern.test(value)) return null\n  const parts = value.split(\".\").map((part) => Number(part))\n  const major = parts[0]\n  const minor = parts.length > 1 ? parts[1] : 0\n  const patch = parts.length > 2 ? parts[2] : 0\n\n  if (parts.length == 1) return {lower: [major, 0, 0], upper: [major + 1, 0, 0]}\n  if (parts.length == 2) return {lower: [major, minor, 0], upper: [major, minor + 1, 0]}\n  return {lower: [major, minor, patch], upper: [major, minor, patch + 1]}\n}\n\n/**\n * Compares two exact version tuples.\n * @param {VersionTuple} left - Left version.\n * @param {VersionTuple} right - Right version.\n * @returns {number} Negative, zero, or positive ordering.\n */\nexport function compareStdlibVersions(left, right) {\n  for (let index = 0; index < 3; index += 1) {\n    if (left[index] != right[index]) return left[index] < right[index] ? -1 : 1\n  }\n  return 0\n}\n\n/**\n * Derives one protected native provider entry name.\n * @param {string} target - Adopted provider target language.\n * @param {string} module - Legacy operation name or canonical module identity.\n * @param {string} [operation] - Qualified canonical operation name.\n * @returns {string} Protected native entry name.\n */\nexport function protectedEntryName(target, module, operation) {\n  if (typeof target != \"string\" || !/^[a-z][a-z0-9-]*$/u.test(target) ||\n    typeof module != \"string\" || (operation !== undefined && (typeof operation != \"string\" ||\n      !declarationNamePattern.test(operation)))) invalidContract(\"Protected provider entry components are invalid.\")\n  if (operation === undefined) {\n    if (!declarationNamePattern.test(module)) invalidContract(\"Protected provider operation name is invalid.\")\n    return `__semantifold_provider_${target}_${module}`\n  }\n  if (!identityPattern.test(module)) invalidContract(\"Protected provider module identity is invalid.\")\n  const encodedModule = [...module].map((character) => character.charCodeAt(0).toString(16).padStart(2, \"0\")).join(\"\")\n\n  return `__semantifold_provider_${target}_m${encodedModule.length}_${encodedModule}_${operation}`\n}\n\n/**\n * Parses one protected native provider entry name.\n * @param {string} name - Candidate protected entry name.\n * @returns {{target: string, module?: string, operation: string} | null} Parsed binding or null when unparseable.\n */\nexport function parseProtectedEntryName(name) {\n  const qualified = /^__semantifold_provider_([a-z][a-z0-9-]*)_m([0-9]+)_([0-9a-f]+)_([A-Za-z_][A-Za-z0-9_]*)$/u.exec(name)\n\n  if (qualified) {\n    const encodedLength = Number(qualified[2])\n    const encoded = qualified[3]\n\n    if (!Number.isSafeInteger(encodedLength) || encodedLength != encoded.length || encoded.length % 2 != 0) return null\n    let module = \"\"\n\n    for (let index = 0; index < encoded.length; index += 2) module += String.fromCharCode(Number.parseInt(encoded.slice(index, index + 2), 16))\n    if (!identityPattern.test(module) || protectedEntryName(qualified[1], module, qualified[4]) != name) return null\n    return {module, operation: qualified[4], target: qualified[1]}\n  }\n  const match = /^__semantifold_provider_([a-z][a-z0-9-]*)_(.+)$/u.exec(name)\n  if (!match) return null\n  return {operation: match[2], target: match[1]}\n}\n\n/**\n * Intersects two half-open version ranges.\n * @param {VersionRange} left - Left range.\n * @param {VersionRange} right - Right range.\n * @returns {VersionRange | null} Intersection or null when empty.\n */\nexport function intersectStdlibVersionRanges(left, right) {\n  const lower = compareStdlibVersions(left.lower, right.lower) >= 0 ? left.lower : right.lower\n  const upper = left.upper === null ? right.upper : right.upper === null ? left.upper :\n    compareStdlibVersions(left.upper, right.upper) <= 0 ? left.upper : right.upper\n\n  if (upper !== null && compareStdlibVersions(lower, upper) >= 0) return null\n  return {lower, upper}\n}\n\n/**\n * Checks whether one exact version satisfies one half-open range.\n * @param {VersionTuple} version - Candidate version.\n * @param {VersionRange} range - Declared range.\n * @returns {boolean} Whether the version satisfies the range.\n */\nexport function stdlibVersionSatisfies(version, range) {\n  if (compareStdlibVersions(version, range.lower) < 0) return false\n  return range.upper === null || compareStdlibVersions(version, range.upper) < 0\n}\n\n/**\n * Creates the built-in versioned canonical stdlib contract registry.\n * @param {unknown} records - Optional override record set; built-in probe contract by default.\n * @returns {Readonly<StdlibContractRegistry>} Frozen registry.\n */\nexport function createStdlibContractRegistry(records = builtinContracts()) {\n  if (!isDenseArray(records)) invalidContract(\"Canonical contract records must be an ordered dense array.\")\n\n  /** @type {Map<string, Map<string, StdlibContractModule>>} */\n  const modules = new Map()\n\n  for (const candidate of records) {\n    const record = validateContractRecord(candidate)\n    const versions = modules.get(record.identity) ?? new Map()\n\n    if (versions.has(record.version)) invalidContract(`Duplicate canonical contract '${record.identity}' version '${record.version}'.`)\n    versions.set(record.version, record)\n    modules.set(record.identity, versions)\n  }\n  for (const record of modules.values()) {\n    for (const module of record.values()) validateContractDependencies(module, modules)\n  }\n  const frozenModules = [...modules.entries()]\n    .map(([identity, versions]) => ({\n      identity,\n      versions: [...versions.keys()].map((version) => /** @type {VersionTuple} */ (parseStdlibVersion(version)))\n        .sort(compareStdlibVersions)\n        .map(([major, minor, patch]) => `${major}.${minor}.${patch}`)\n    }))\n    .map(deepFreeze)\n  const store = deepFreeze(/** @type {{modules: [string, Readonly<Map<string, Readonly<StdlibContractModule>>>][]}} */ ({\n    modules: [...modules.entries()].map(([identity, versions]) => [identity, deepFreeze(versions)])\n  }))\n  return Object.freeze(/** @type {StdlibContractRegistry} */ ({\n    modules: Object.freeze(frozenModules),\n    resolveModule(identity, range) {\n      return resolveRegistryModule(store, identity, range)\n    }\n  }))\n}\n\n/**\n * Resolves one module identity plus optional range against one registry store.\n * @param {{modules: [string, Readonly<Map<string, Readonly<StdlibContractModule>>>][]}} store - Registry store.\n * @param {string} identity - Canonical module identity.\n * @param {string | undefined} [range] - Declared version range.\n * @returns {StdlibContract} Detached frozen contract.\n */\nfunction resolveRegistryModule(store, identity, range) {\n  const versions = store.modules.find(([candidate]) => candidate == identity)?.[1]\n\n  if (!versions) unknownModule(identity)\n  const parsed = range === undefined ? /** @type {VersionRange} */ ({lower: [0, 0, 0], upper: null}) : parseStdlibVersionRange(range)\n\n  if (!parsed) malformedRange()\n  /** @type {VersionTuple | undefined} */\n  let resolved\n\n  for (const version of versions.keys()) {\n    const tuple = /** @type {VersionTuple} */ (parseStdlibVersion(version))\n\n    if (stdlibVersionSatisfies(tuple, parsed) && (resolved === undefined || compareStdlibVersions(tuple, resolved) > 0)) {\n      resolved = tuple\n    }\n  }\n  if (resolved === undefined) incompatibleVersion(identity)\n  const record = /** @type {Readonly<StdlibContractModule>} */ (versions.get(`${resolved[0]}.${resolved[1]}.${resolved[2]}`))\n\n  return deepFreeze({\n    dependencies: record.dependencies,\n    failures: record.failures,\n    identity: record.identity,\n    operations: record.operations,\n    resources: record.resources,\n    schema: /** @type {const} */ (\"SemantifoldStdlibContract\"),\n    schemaVersion: /** @type {const} */ (1),\n    version: `${resolved[0]}.${resolved[1]}.${resolved[2]}`\n  })\n}\n\n/**\n * Lists the built-in canonical stdlib modules with their registered versions.\n * @returns {Readonly<{identity: string, versions: string[]}[]>} Frozen module list.\n */\nexport function listStdlibModules() {\n  return builtinRegistry.modules\n}\n\n/**\n * Resolves one built-in canonical stdlib module by identity and optional range.\n * @param {string} identity - Canonical module identity.\n * @param {string} [range] - Declared version range.\n * @returns {StdlibContract} Detached frozen contract.\n */\nexport function resolveStdlibModule(identity, range) {\n  return builtinRegistry.resolveModule(identity, range)\n}\n\n/**\n * Declares the built-in Task 034 resource-probe canonical contract.\n * @returns {unknown} Unvalidated built-in record.\n */\nfunction builtinProbeContract() {\n  return {\n    dependencies: [],\n    failures: [\n      {name: \"ProbeOperationFailure\"},\n      {name: \"ProbeAcquireFailure\"},\n      {name: \"ProbeReadFailure\"},\n      {name: \"ProbeCloseFailure\"},\n      {name: \"ProbeResourceClosed\"}\n    ],\n    identity: \"semantifold.task034.resource-probe\",\n    operations: [\n      {\n        dependencies: [],\n        effects: [\"host\"],\n        evaluationOrder: \"left-to-right\",\n        failures: [\"ProbeOperationFailure\"],\n        name: \"probeEffect\",\n        parameters: [{name: \"label\", type: \"string\"}, {name: \"value\", type: \"integer\"}, {name: \"fail\", type: \"boolean\"}],\n        resourceFlow: {kind: \"none\"},\n        returnType: \"integer\",\n        semantics: canonicalSemantics()\n      },\n      {\n        dependencies: [],\n        effects: [\"host\"],\n        evaluationOrder: \"left-to-right\",\n        failures: [\"ProbeAcquireFailure\"],\n        name: \"probeAcquire\",\n        parameters: [{name: \"fail\", type: \"boolean\"}],\n        resourceFlow: {kind: \"acquire\", resource: \"ProbeResource\"},\n        returnType: \"ProbeResource\",\n        semantics: canonicalSemantics({ownership: \"acquired\"})\n      },\n      {\n        dependencies: [],\n        effects: [\"host\"],\n        evaluationOrder: \"left-to-right\",\n        failures: [\"ProbeReadFailure\", \"ProbeResourceClosed\"],\n        name: \"probeRead\",\n        parameters: [{name: \"resource\", type: \"ProbeResource\"}, {name: \"fail\", type: \"boolean\"}],\n        resourceFlow: {kind: \"borrow\", parameterIndex: 0, terminalFailure: \"ProbeResourceClosed\"},\n        returnType: \"optional:string\",\n        semantics: canonicalSemantics({\n          close: \"use-after-close-fails\",\n          eof: \"absent-value\",\n          encoding: \"utf-8\",\n          newline: \"strip-line-terminator\",\n          ownership: \"borrowed\"\n        })\n      },\n      {\n        dependencies: [],\n        effects: [\"host\"],\n        evaluationOrder: \"left-to-right\",\n        failures: [\"ProbeCloseFailure\", \"ProbeResourceClosed\"],\n        name: \"probeClose\",\n        parameters: [{name: \"resource\", type: \"ProbeResource\"}, {name: \"fail\", type: \"boolean\"}],\n        resourceFlow: {kind: \"close\", parameterIndex: 0, terminalFailure: \"ProbeResourceClosed\"},\n        returnType: \"void\",\n        semantics: canonicalSemantics({close: \"repeated-close-fails\", ownership: \"consumed\"})\n      },\n      {\n        dependencies: [],\n        effects: [\"host\"],\n        evaluationOrder: \"left-to-right\",\n        failures: [],\n        name: \"probeTrace\",\n        parameters: [],\n        resourceFlow: {kind: \"none\"},\n        returnType: \"string\",\n        semantics: canonicalSemantics()\n      }\n    ],\n    resources: [{name: \"ProbeResource\"}],\n    version: \"1.0.0\"\n  }\n}\n\n/**\n * Declares the complete built-in canonical registry input.\n * @returns {unknown[]} Unvalidated built-in records.\n */\nfunction builtinContracts() {\n  return [builtinProbeContract(), builtinSocketClientContract(), builtinTextStreamContract(),\n    builtinOutputContract(), builtinResourceContract()]\n}\n\n/**\n * Declares the built-in SocketClient v1 contract.\n * @returns {unknown} Unvalidated SocketClient v1 record.\n */\nfunction builtinSocketClientContract() {\n  const byteStream = {module: \"semantifold.resource\", name: \"ByteStream\"}\n\n  return {\n    dependencies: [{module: \"semantifold.resource\", range: \"1\"}],\n    failures: [{name: \"InvalidHost\"}, {name: \"InvalidPort\"}, {name: \"ConnectionFailure\"}],\n    identity: \"semantifold.socket-client\",\n    operations: [{\n      dependencies: [], effects: [\"host\"], evaluationOrder: \"left-to-right\",\n      failures: [\"InvalidHost\", \"InvalidPort\", \"ConnectionFailure\"], name: \"v1_connect\",\n      parameters: [{name: \"host\", type: \"string\"}, {name: \"port\", type: \"integer\"}],\n      resourceFlow: {kind: \"acquire\", resource: byteStream}, returnType: byteStream,\n      semantics: canonicalSemantics({ownership: \"acquired\"})\n    }],\n    resources: [],\n    version: \"1.0.0\"\n  }\n}\n\n/**\n * Declares the built-in TextStream v1 contract.\n * @returns {unknown} Unvalidated TextStream v1 record.\n */\nfunction builtinTextStreamContract() {\n  const byteStream = {module: \"semantifold.resource\", name: \"ByteStream\"}\n  const resourceClosed = {module: \"semantifold.resource\", name: \"ResourceClosed\"}\n\n  return {\n    dependencies: [{module: \"semantifold.resource\", range: \"1\"}],\n    failures: [{name: \"ReadFailure\"}, {name: \"DecodeFailure\"}],\n    identity: \"semantifold.text-stream\",\n    operations: [{\n      dependencies: [], effects: [\"host\"], evaluationOrder: \"left-to-right\",\n      failures: [\"ReadFailure\", \"DecodeFailure\", resourceClosed], name: \"v1_read_line\",\n      parameters: [{name: \"resource\", type: byteStream}],\n      resourceFlow: {kind: \"borrow\", parameterIndex: 0, terminalFailure: resourceClosed},\n      returnType: \"optional:string\",\n      semantics: canonicalSemantics({close: \"use-after-close-fails\", eof: \"absent-value\", encoding: \"utf-8\",\n        newline: \"retain-line-terminator\", ownership: \"borrowed\"})\n    }],\n    resources: [],\n    version: \"1.0.0\"\n  }\n}\n\n/**\n * Declares the built-in Output v1 contract.\n * @returns {unknown} Unvalidated Output v1 record.\n */\nfunction builtinOutputContract() {\n  return {\n    dependencies: [], failures: [{name: \"WriteFailure\"}], identity: \"semantifold.output\",\n    operations: [{\n      dependencies: [], effects: [\"host\"], evaluationOrder: \"left-to-right\", failures: [\"WriteFailure\"],\n      name: \"v1_write_line\", parameters: [{name: \"text\", type: \"string\"}], resourceFlow: {kind: \"none\"},\n      returnType: \"void\", semantics: canonicalSemantics({encoding: \"utf-8\", newline: \"append-lf-if-missing\"})\n    }],\n    resources: [], version: \"1.0.0\"\n  }\n}\n\n/**\n * Declares the built-in Resource v1 contract.\n * @returns {unknown} Unvalidated Resource v1 record.\n */\nfunction builtinResourceContract() {\n  return {\n    dependencies: [], failures: [{name: \"CloseFailure\"}, {name: \"ResourceClosed\"}], identity: \"semantifold.resource\",\n    operations: [{\n      dependencies: [], effects: [\"host\"], evaluationOrder: \"left-to-right\",\n      failures: [\"CloseFailure\", \"ResourceClosed\"], name: \"v1_close\",\n      parameters: [{name: \"resource\", type: \"ByteStream\"}],\n      resourceFlow: {kind: \"close\", parameterIndex: 0, terminalFailure: \"ResourceClosed\"}, returnType: \"void\",\n      semantics: canonicalSemantics({close: \"repeated-close-fails\", ownership: \"consumed\"})\n    }],\n    resources: [{name: \"ByteStream\"}], version: \"1.0.0\"\n  }\n}\n\n/**\n * Builds one closed semantics declaration with canonical defaults.\n * @param {Partial<Record<keyof typeof semanticsValues, string>>} [overrides] - Non-default closed values.\n * @returns {Record<string, string>} Closed semantics fields.\n */\nfunction canonicalSemantics(overrides = {}) {\n  return {\n    blocking: \"synchronous\",\n    close: \"not-applicable\",\n    eof: \"not-applicable\",\n    encoding: \"not-applicable\",\n    newline: \"not-applicable\",\n    ownership: \"not-applicable\",\n    timeout: \"none\",\n    ...overrides\n  }\n}\n\n/**\n * Validates one canonical contract record and returns a detached clone.\n * @param {unknown} candidate - Candidate record.\n * @returns {StdlibContractModule} Detached record.\n */\nfunction validateContractRecord(candidate) {\n  if (!isPlainObject(candidate)) invalidContract(\"Every canonical contract record must be a plain object.\")\n  requireKeys(candidate, [\"dependencies\", \"failures\", \"identity\", \"operations\", \"resources\", \"version\"], \"contract record\")\n  const identity = /** @type {string} */ (candidate.identity)\n\n  if (typeof identity != \"string\" || !identityPattern.test(identity)) invalidContract(\"Canonical contract identity is invalid.\")\n  const version = /** @type {string} */ (candidate.version)\n\n  if (parseStdlibVersion(version) === null) invalidContract(`Canonical contract version '${String(version)}' is invalid.`)\n  const resources = validateNamedList(candidate.resources, \"resource\")\n  const failures = validateNamedList(candidate.failures, \"failure\")\n  const resourceNames = new Set(resources.map(({name}) => name))\n  const failureNames = new Set(failures.map(({name}) => name))\n  const operationNames = new Set()\n  const dependencies = validateModuleDependencies(candidate.dependencies, identity)\n\n  if (!isDenseArray(candidate.operations)) invalidContract(\"Canonical contract operations must be a dense array.\")\n  const operations = /** @type {unknown[]} */ (candidate.operations).map((operation) =>\n    validateContractOperation(operation, resourceNames, failureNames, operationNames))\n\n  return deepFreeze({\n    dependencies,\n    failures,\n    identity,\n    operations,\n    resources,\n    version: /** @type {string} */ (version)\n  })\n}\n\n/**\n * Validates one canonical contract operation.\n * @param {unknown} candidate - Candidate operation.\n * @param {Set<string>} resourceNames - Declared resource names.\n * @param {Set<string>} failureNames - Declared failure names.\n * @param {Set<string>} operationNames - Already-declared operation names.\n * @returns {StdlibContractOperation} Detached operation.\n */\nfunction validateContractOperation(candidate, resourceNames, failureNames, operationNames) {\n  if (!isPlainObject(candidate)) invalidContract(\"Every canonical contract operation must be a plain object.\")\n  requireKeys(candidate, [\"dependencies\", \"effects\", \"evaluationOrder\", \"failures\", \"name\", \"parameters\", \"resourceFlow\", \"returnType\", \"semantics\"], \"contract operation\")\n  const name = /** @type {string} */ (candidate.name)\n\n  if (typeof name != \"string\" || !declarationNamePattern.test(name) || operationNames.has(name)) {\n    invalidContract(\"Canonical contract operation name is invalid or duplicate.\")\n  }\n  operationNames.add(name)\n  if (!isDenseArray(candidate.effects) || candidate.effects.length != 1 || candidate.effects[0] != \"host\") {\n    invalidContract(`Operation '${name}' requires the single host effect declaration.`)\n  }\n  if (candidate.evaluationOrder != \"left-to-right\") invalidContract(`Operation '${name}' requires left-to-right evaluation.`)\n  if (!isDenseArray(candidate.failures)) {\n    invalidContract(`Operation '${name}' declares unknown or duplicate failures.`)\n  }\n  const failures = candidate.failures.map((failure) => normalizeDeclarationReference(failure, failureNames, `Operation '${name}' failure`))\n  if (new Set(failures.map(referenceKey)).size != failures.length) invalidContract(`Operation '${name}' repeats a declared failure.`)\n  const parameterNames = new Set()\n  /** @type {{name: string, type: string | CanonicalDeclarationReference}[]} */\n  const parameters = []\n\n  if (!isDenseArray(candidate.parameters)) invalidContract(`Operation '${name}' parameters must be a dense array.`)\n  for (const parameter of /** @type {unknown[]} */ (candidate.parameters)) {\n    if (!isPlainObject(parameter)) invalidContract(`Operation '${name}' parameters must be plain objects.`)\n    requireKeys(parameter, [\"name\", \"type\"], `operation '${name}' parameter`)\n    const parameterName = /** @type {string} */ (parameter.name)\n\n    if (typeof parameterName != \"string\" || !declarationNamePattern.test(parameterName) || parameterNames.has(parameterName)) {\n      invalidContract(`Operation '${name}' parameter name is invalid or duplicate.`)\n    }\n    parameterNames.add(parameterName)\n    const parameterType = normalizeCanonicalValueType(parameter.type, resourceNames, `operation '${name}' parameter '${parameterName}'`)\n\n    if (parameterType === null) {\n      invalidContract(`Operation '${name}' parameter '${parameterName}' type is outside the closed canonical value set.`)\n    }\n    parameters.push({name: parameterName, type: parameterType})\n  }\n  const returnType = candidate.returnType == \"void\" ? \"void\" : normalizeCanonicalValueType(candidate.returnType, resourceNames, `operation '${name}' return type`)\n\n  if (returnType === null) {\n    invalidContract(`Operation '${name}' return type is outside the closed canonical value set.`)\n  }\n  const resourceFlow = validateContractResourceFlow(candidate.resourceFlow, parameters, failures, name)\n  const dependencies = validateOperationDependencies(candidate.dependencies)\n  const semantics = validateContractSemantics(candidate.semantics, name)\n\n  return deepFreeze({\n    dependencies,\n    effects: /** @type {const} */ ([\"host\"]),\n    evaluationOrder: /** @type {const} */ (\"left-to-right\"),\n    failures,\n    name,\n    parameters,\n    resourceFlow,\n    returnType,\n    semantics\n  })\n}\n\n/**\n * Validates one closed canonical value type spelling.\n * @param {unknown} candidate - Candidate type.\n * @param {Set<string>} resourceNames - Declared resource names.\n * @param {string} _subject - Diagnostic subject reserved for caller context.\n * @returns {string | CanonicalDeclarationReference | null} Detached type or null.\n */\nfunction normalizeCanonicalValueType(candidate, resourceNames, _subject) {\n  if (typeof candidate == \"string\") {\n    if (scalarNames.has(candidate) || resourceNames.has(candidate)) return candidate\n    const optional = /^optional:([a-z]+)$/u.exec(candidate)\n\n    return optional && scalarNames.has(optional[1]) ? candidate : null\n  }\n  if (isPlainObject(candidate) && Object.keys(candidate).sort().join(\",\") == \"module,name\" &&\n    typeof candidate.module == \"string\" && identityPattern.test(candidate.module) && typeof candidate.name == \"string\" &&\n    declarationNamePattern.test(candidate.name)) return {module: candidate.module, name: candidate.name}\n  return null\n}\n\n/**\n * Validates one closed resource transition against its parameters and failures.\n * @param {unknown} candidate - Candidate transition.\n * @param {{name: string, type: string | CanonicalDeclarationReference}[]} parameters - Validated parameters.\n * @param {(string | CanonicalDeclarationReference)[]} failures - Validated failure names.\n * @param {string} operation - Operation name.\n * @returns {object} Detached transition.\n */\nfunction validateContractResourceFlow(candidate, parameters, failures, operation) {\n  if (!isPlainObject(candidate)) invalidContract(`Operation '${operation}' requires a resource flow declaration.`)\n  const ownedParameters = parameters.flatMap((parameter, index) => isOwnedCanonicalType(parameter.type) ? [index] : [])\n\n  if (Object.keys(candidate).sort().join(\",\") == \"kind\" && candidate.kind == \"none\") {\n    if (ownedParameters.length > 0) invalidContract(`Operation '${operation}' owns a parameter without a transition.`)\n    return deepFreeze({kind: /** @type {const} */ (\"none\")})\n  }\n  if (Object.keys(candidate).sort().join(\",\") == \"kind,resource\" && candidate.kind == \"acquire\") {\n    const resource = typeof candidate.resource == \"string\" && declarationNamePattern.test(candidate.resource)\n      ? candidate.resource\n      : normalizeCanonicalValueType(candidate.resource, new Set(), `operation '${operation}' acquisition`)\n    if (resource === null || ownedParameters.length > 0) {\n      invalidContract(`Operation '${operation}' acquisition flow is incomplete.`)\n    }\n    return deepFreeze({kind: /** @type {const} */ (\"acquire\"), resource})\n  }\n  if ([\"borrow\", \"close\"].includes(String(candidate.kind)) &&\n    Object.keys(candidate).sort().join(\",\") == \"kind,parameterIndex,terminalFailure\") {\n    const parameterIndex = /** @type {number} */ (candidate.parameterIndex)\n\n    if (!Number.isSafeInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= parameters.length ||\n      ownedParameters.length != 1 || ownedParameters[0] != parameterIndex ||\n      !failures.some((failure) => referenceKey(failure) == referenceKey(candidate.terminalFailure))) {\n      invalidContract(`Operation '${operation}' ${String(candidate.kind)} flow is incomplete.`)\n    }\n    return deepFreeze({kind: /** @type {\"borrow\" | \"close\"} */ (candidate.kind), parameterIndex,\n      terminalFailure: normalizeFailureFlowReference(candidate.terminalFailure)})\n  }\n  return invalidContract(`Operation '${operation}' declares an unknown resource flow.`)\n}\n\n/**\n * Validates one canonical operation dependency list.\n * @param {unknown} candidate - Candidate dependencies.\n * @returns {{module: string, operation: string, range: VersionRange}[]} Detached dependencies.\n */\nfunction validateOperationDependencies(candidate) {\n  if (!isDenseArray(candidate)) invalidContract(\"Canonical contract dependencies must be a dense array.\")\n  /** @type {{module: string, operation: string, range: VersionRange}[]} */\n  const dependencies = []\n\n  for (const dependency of candidate) {\n    if (!isPlainObject(dependency)) invalidContract(\"Every canonical contract dependency must be a plain object.\")\n    requireKeys(dependency, [\"module\", \"operation\", \"range\"], \"contract dependency\")\n    const module = /** @type {string} */ (dependency.module)\n    const operation = /** @type {string} */ (dependency.operation)\n    const range = parseStdlibVersionRange(dependency.range)\n\n    if (typeof module != \"string\" || !identityPattern.test(module) ||\n      typeof operation != \"string\" || !declarationNamePattern.test(operation) || range === null) {\n      invalidContract(\"Canonical contract dependency module, operation, or range is invalid.\")\n    }\n    dependencies.push({module, operation, range})\n  }\n  return dependencies\n}\n\n/**\n * Validates canonical operation dependencies against the complete registry identity set.\n * @param {StdlibContractModule} record - Validated record.\n * @param {Map<string, Map<string, StdlibContractModule>>} modules - All registered module versions.\n * @returns {void}\n */\nfunction validateContractDependencies(record, modules) {\n  const allowedDependencies = new Map(record.dependencies.map((dependency) => [dependency.module, dependency.range]))\n\n  for (const dependency of record.dependencies) {\n    const versions = modules.get(dependency.module)\n\n    if (!versions || ![...versions.keys()].some((version) => stdlibVersionSatisfies(/** @type {VersionTuple} */ (parseStdlibVersion(version)), dependency.range))) {\n      invalidContract(`Canonical module '${record.identity}' depends on missing or incompatible module '${dependency.module}'.`)\n    }\n  }\n  for (const operation of record.operations) {\n    for (const reference of operation.parameters.map(({type}) => type).concat([operation.returnType]).filter(isDeclarationReference)) {\n      validateForeignDeclarationReference(record, reference, \"resource\", allowedDependencies, modules)\n    }\n    for (const reference of operation.failures.filter(isDeclarationReference)) {\n      validateForeignDeclarationReference(record, reference, \"failure\", allowedDependencies, modules)\n    }\n    for (const dependency of operation.dependencies) {\n      if (!modules.has(dependency.module)) {\n        invalidContract(`Operation '${operation.name}' depends on unknown canonical module '${dependency.module}'.`)\n      }\n      if (dependency.module == record.identity && dependency.operation == operation.name) {\n        invalidContract(`Operation '${operation.name}' declares a self-cycle dependency.`)\n      }\n    }\n  }\n}\n\n/**\n * Validates declaration-only module dependencies.\n * @param {unknown} candidate - Candidate dependency list.\n * @param {string} identity - Owning module identity.\n * @returns {{module: string, range: VersionRange}[]} Detached dependencies.\n */\nfunction validateModuleDependencies(candidate, identity) {\n  if (!isDenseArray(candidate)) invalidContract(\"Canonical module dependencies must be a dense array.\")\n  const names = new Set()\n\n  return candidate.map((dependency) => {\n    if (!isPlainObject(dependency)) invalidContract(\"Every canonical module dependency must be a plain object.\")\n    requireKeys(dependency, [\"module\", \"range\"], \"module dependency\")\n    const module = /** @type {string} */ (dependency.module)\n    const range = parseStdlibVersionRange(dependency.range)\n\n    if (typeof module != \"string\" || !identityPattern.test(module) || module == identity || names.has(module) || range === null) {\n      invalidContract(\"Canonical module dependency is invalid, duplicate, self-referential, or malformed.\")\n    }\n    names.add(module)\n    return {module, range}\n  })\n}\n\n/**\n * Validates one dependency-qualified resource or failure reference.\n * @param {StdlibContractModule} record - Owning module.\n * @param {CanonicalDeclarationReference} reference - Qualified declaration.\n * @param {\"resource\" | \"failure\"} kind - Declaration kind.\n * @param {Map<string, VersionRange>} allowedDependencies - Direct dependency ranges.\n * @param {Map<string, Map<string, StdlibContractModule>>} modules - Registry modules.\n * @returns {void}\n */\nfunction validateForeignDeclarationReference(record, reference, kind, allowedDependencies, modules) {\n  const range = allowedDependencies.get(reference.module)\n\n  if (!range) invalidContract(`Canonical module '${record.identity}' uses undeclared dependency '${reference.module}'.`)\n  const versions = /** @type {Map<string, StdlibContractModule>} */ (modules.get(reference.module))\n  const matches = [...versions.values()].filter((module) =>\n    stdlibVersionSatisfies(/** @type {VersionTuple} */ (parseStdlibVersion(module.version)), range))\n  const declarations = kind == \"resource\" ? matches.flatMap(({resources}) => resources) : matches.flatMap(({failures}) => failures)\n\n  if (!declarations.some(({name}) => name == reference.name)) {\n    invalidContract(`Canonical ${kind} '${reference.module}.${reference.name}' is not declared by a compatible dependency.`)\n  }\n}\n\n/**\n * Normalizes one local or dependency-qualified declaration reference.\n * @param {unknown} candidate - Candidate reference.\n * @param {Set<string>} localNames - Declared local names.\n * @param {string} subject - Diagnostic subject.\n * @returns {string | CanonicalDeclarationReference} Detached reference.\n */\nfunction normalizeDeclarationReference(candidate, localNames, subject) {\n  if (typeof candidate == \"string\" && localNames.has(candidate)) return candidate\n  if (isDeclarationReference(candidate)) return {module: candidate.module, name: candidate.name}\n  return invalidContract(`${subject} is not a declared local or qualified canonical declaration.`)\n}\n\n/**\n * Normalizes a terminal failure reference after membership validation.\n * @param {unknown} candidate - Candidate failure reference.\n * @returns {string | CanonicalDeclarationReference} Detached reference.\n */\nfunction normalizeFailureFlowReference(candidate) {\n  if (typeof candidate == \"string\") return candidate\n  if (isDeclarationReference(candidate)) return {module: candidate.module, name: candidate.name}\n  return invalidContract(\"Resource flow terminal failure is invalid.\")\n}\n\n/**\n * Checks one canonical qualified declaration reference.\n * @param {unknown} candidate - Candidate reference.\n * @returns {candidate is CanonicalDeclarationReference} Whether the reference is exact.\n */\nfunction isDeclarationReference(candidate) {\n  return isPlainObject(candidate) && Object.keys(candidate).sort().join(\",\") == \"module,name\" &&\n    typeof candidate.module == \"string\" && identityPattern.test(candidate.module) &&\n    typeof candidate.name == \"string\" && declarationNamePattern.test(candidate.name)\n}\n\n/**\n * Encodes one declaration reference for equality checks.\n * @param {unknown} candidate - Local or qualified reference.\n * @returns {string} Stable equality key.\n */\nfunction referenceKey(candidate) {\n  return typeof candidate == \"string\" ? `local:${candidate}` : isDeclarationReference(candidate)\n    ? `${candidate.module}:${candidate.name}` : `invalid:${String(candidate)}`\n}\n\n/**\n * Reports whether a canonical type denotes an owned resource.\n * @param {string | CanonicalDeclarationReference} candidate - Canonical type.\n * @returns {boolean} Whether the type is owned.\n */\nfunction isOwnedCanonicalType(candidate) {\n  return isDeclarationReference(candidate) || (typeof candidate == \"string\" && !scalarNames.has(candidate) &&\n    !candidate.startsWith(\"optional:\") && candidate != \"void\")\n}\n\n/**\n * Validates one closed semantics declaration.\n * @param {unknown} candidate - Candidate semantics.\n * @param {string} operation - Operation name.\n * @returns {Record<string, string>} Closed semantics fields.\n */\nfunction validateContractSemantics(candidate, operation) {\n  if (!isPlainObject(candidate) || Object.keys(candidate).sort().join(\",\") !=\n    \"blocking,close,encoding,eof,newline,ownership,timeout\") {\n    invalidContract(`Operation '${operation}' requires the closed canonical semantics fields.`)\n  }\n  /** @type {Record<string, string>} */\n  const semantics = {}\n\n  for (const [field, allowed] of Object.entries(semanticsValues)) {\n    const value = /** @type {string} */ (candidate[field])\n\n    if (typeof value != \"string\" || !allowed.has(value)) {\n      invalidContract(`Operation '${operation}' declares a non-canonical '${field}' semantics value.`)\n    }\n    semantics[field] = value\n  }\n  return deepFreeze(semantics)\n}\n\n/**\n * Validates one dense ordered single-field named declaration list.\n * @param {unknown} candidate - Candidate list.\n * @param {string} subject - Diagnostic subject.\n * @returns {{name: string}[]} Detached declarations.\n */\nfunction validateNamedList(candidate, subject) {\n  if (!isDenseArray(candidate)) invalidContract(`Canonical contract ${subject}s must be a dense array.`)\n  const names = new Set()\n  /** @type {{name: string}[]} */\n  const declarations = []\n\n  for (const declaration of candidate) {\n    if (!isPlainObject(declaration) || Object.keys(declaration).join(\",\") != \"name\" ||\n      typeof declaration.name != \"string\" || !declarationNamePattern.test(declaration.name) || names.has(declaration.name)) {\n      invalidContract(`Canonical contract ${subject} declarations must be uniquely named.`)\n    }\n    names.add(/** @type {string} */ (declaration.name))\n    declarations.push({name: /** @type {string} */ (declaration.name)})\n  }\n  return declarations\n}\n\n/**\n * Reports an unknown canonical module identity.\n * @param {string} identity - Unknown identity.\n * @returns {never} Always throws.\n */\nfunction unknownModule(identity) {\n  throw new SemantifoldDiagnostic({code: \"STDLIB_MODULE_UNKNOWN\", language: \"stdlib\",\n    message: `Standard-library module '${identity}' is not a registered canonical contract.`})\n}\n\n/**\n * Reports one malformed version range.\n * @returns {never} Always throws.\n */\nfunction malformedRange() {\n  throw new SemantifoldDiagnostic({code: \"STDLIB_VERSION_MALFORMED\", language: \"stdlib\",\n    message: \"Standard-library version ranges use X, X.Y, or X.Y.Z without leading zeros or prerelease labels.\"})\n}\n\n/**\n * Reports one unsatisfiable version range.\n * @param {string} identity - Constrained module identity.\n * @returns {never} Always throws.\n */\nfunction incompatibleVersion(identity) {\n  throw new SemantifoldDiagnostic({code: \"STDLIB_VERSION_INCOMPATIBLE\", language: \"stdlib\",\n    message: `No registered version of '${identity}' satisfies the declared standard-library version range.`})\n}\n\n/**\n * Raises one stable canonical contract diagnostic.\n * @param {string} message - Diagnostic message.\n * @returns {never} Always throws.\n */\nfunction invalidContract(message) {\n  throw new SemantifoldDiagnostic({code: \"STDLIB_CONTRACT_INVALID\", language: \"stdlib\", message})\n}\n\n/**\n * Requires one exact field set.\n * @param {Record<string, unknown>} value - Candidate object.\n * @param {string[]} keys - Required keys.\n * @param {string} subject - Diagnostic subject.\n * @returns {void}\n */\nfunction requireKeys(value, keys, subject) {\n  if (Object.keys(value).sort().join(\",\") != [...keys].sort().join(\",\")) invalidContract(`Invalid ${subject} fields.`)\n}\n\n/**\n * Checks an ordered dense array.\n * @param {unknown} value - Candidate array.\n * @returns {value is unknown[]} Whether the value is dense.\n */\nfunction isDenseArray(value) {\n  return Array.isArray(value) && value.every((_item, index) => Object.hasOwn(value, index))\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  return value !== null && typeof value == \"object\" && !Array.isArray(value) &&\n    Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Recursively freezes a detached value.\n * @template {object} Value\n * @param {Value} value - Object to freeze.\n * @returns {Readonly<Value>} Frozen object.\n */\nfunction deepFreeze(value) {\n  for (const child of Object.values(value)) {\n    if (child && typeof child == \"object\" && !Object.isFrozen(child)) deepFreeze(child)\n  }\n  return Object.freeze(value)\n}\n\n/** @type {Readonly<StdlibContractRegistry>} */\nconst builtinRegistry = createStdlibContractRegistry()\n"]}