semantifold 0.3.0 → 0.4.0

package/build/src/semantic/capabilities.js

@@ -0,0 +1,649 @@
+// @ts-check
+import { SemantifoldDiagnostic } from "../diagnostic.js";
+import { parseStdlibVersionRange } from "./stdlib.js";
+const authoritySchema = "SemantifoldCapabilityAuthority";
+const authorityIdPattern = /^[a-z][a-z0-9.-]*$/u;
+const declarationNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+const scalarNames = new Set(["boolean", "integer", "string"]);
+const createdAuthorities = new WeakSet();
+/**
+ * @typedef CapabilityAuthorityV2State
+ * @property {{candidate: import("./types.js").CapabilityDeclarationInput, capabilityId: string, failures: import("./types.js").EffectFailureDeclaration[], resources: import("./types.js").EffectResourceDeclaration[]}[]} capabilities - Prepared capability declarations.
+ * @property {Map<string, string | undefined>} failureNames - Module-local failures.
+ * @property {string} identity - Canonical module identity.
+ * @property {number} moduleIndex - Stable module position.
+ * @property {Map<string, string | undefined>} resourceNames - Module-local resources.
+ * @property {string} contractVersion - Canonical contract range.
+ */
+const task034ProbeOperations = Object.freeze([
+    Object.freeze({ failures: Object.freeze(["capability:0/failure:0"]), flow: Object.freeze({ kind: "none" }),
+        name: "probeEffect", parameters: Object.freeze([["label", "string"], ["value", "integer"], ["fail", "boolean"]]),
+        returnType: "integer" }),
+    Object.freeze({ failures: Object.freeze(["capability:0/failure:1"]),
+        flow: Object.freeze({ kind: "acquire", resourceId: "capability:0/resource:0" }), name: "probeAcquire",
+        parameters: Object.freeze([["fail", "boolean"]]), returnType: "resource" }),
+    Object.freeze({ failures: Object.freeze(["capability:0/failure:2", "capability:0/failure:4"]),
+        flow: Object.freeze({ kind: "borrow", parameterIndex: 0, terminalFailureId: "capability:0/failure:4" }), name: "probeRead",
+        parameters: Object.freeze([["resource", "resource"], ["fail", "boolean"]]), returnType: "optional:string" }),
+    Object.freeze({ failures: Object.freeze(["capability:0/failure:3", "capability:0/failure:4"]),
+        flow: Object.freeze({ kind: "close", parameterIndex: 0, terminalFailureId: "capability:0/failure:4" }), name: "probeClose",
+        parameters: Object.freeze([["resource", "resource"], ["fail", "boolean"]]), returnType: "void" }),
+    Object.freeze({ failures: Object.freeze([]), flow: Object.freeze({ kind: "none" }), name: "probeTrace",
+        parameters: Object.freeze([]), returnType: "string" })
+]);
+/**
+ * Creates an immutable, detached compiler-authority descriptor.
+ * @param {unknown} input - Untrusted authority input.
+ * @returns {Readonly<import("./types.js").CapabilityAuthority>} Normalized authority.
+ */
+export function createCapabilityAuthority(input) {
+    try {
+        if (createdAuthorities.has(/** @type {object} */ (input)))
+            return /** @type {Readonly<import("./types.js").CapabilityAuthority>} */ (input);
+        requirePlain(input, "authority");
+        const authorityInput = /** @type {import("./types.js").CapabilityAuthorityInput} */ (input);
+        if (authorityInput.schemaVersion == 2)
+            return createCapabilityAuthorityV2(authorityInput);
+        const hasContractVersion = Object.hasOwn(authorityInput, "contractVersion");
+        requireKeys(authorityInput, hasContractVersion
+            ? ["capabilities", "contractVersion", "id", "schema", "schemaVersion"]
+            : ["capabilities", "id", "schema", "schemaVersion"], "authority");
+        if (hasContractVersion && parseStdlibVersionRange(authorityInput.contractVersion) === null) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_VERSION_MALFORMED",
+                language: "capability",
+                message: "Capability authority contractVersion is not a canonical stdlib version range."
+            });
+        }
+        if (authorityInput.schema != authoritySchema || authorityInput.schemaVersion != 1 || typeof authorityInput.id != "string" ||
+            !authorityIdPattern.test(authorityInput.id) || !dense(authorityInput.capabilities))
+            invalid("Authority schema, version, identity, or capability list is invalid.");
+        const capabilityNames = new Set();
+        const authorityResourceNames = new Set();
+        const authorityFailureNames = new Set();
+        const authorityOperationNames = new Set();
+        const capabilities = authorityInput.capabilities.map((candidate, capabilityIndex) => {
+            requirePlain(candidate, `capability ${capabilityIndex}`);
+            requireKeys(candidate, ["failures", "name", "operations", "resources"], `capability ${capabilityIndex}`);
+            requireName(candidate.name, capabilityNames, "capability");
+            if (!dense(candidate.resources) || !dense(candidate.failures) || !dense(candidate.operations)) {
+                invalid(`Capability '${candidate.name}' requires ordered resource, failure, and operation arrays.`);
+            }
+            const capabilityId = `capability:${capabilityIndex}`;
+            const resourceNames = new Map();
+            const resources = candidate.resources.map((resource, resourceIndex) => {
+                requireNamed(resource, resourceNames, "resource");
+                requireName(resource.name, authorityResourceNames, "authority resource");
+                const id = `${capabilityId}/resource:${resourceIndex}`;
+                resourceNames.set(resource.name, id);
+                return { id, kind: /** @type {const} */ ("EffectResourceDeclaration"), name: resource.name };
+            });
+            const failureNames = new Map();
+            const failures = candidate.failures.map((failure, failureIndex) => {
+                requireNamed(failure, failureNames, "failure");
+                requireName(failure.name, authorityFailureNames, "authority failure");
+                const id = `${capabilityId}/failure:${failureIndex}`;
+                failureNames.set(failure.name, id);
+                return { id, kind: /** @type {const} */ ("EffectFailureDeclaration"), name: failure.name };
+            });
+            const operationNames = new Set();
+            const operations = candidate.operations.map((operation, operationIndex) => {
+                requirePlain(operation, `operation ${operationIndex}`);
+                requireKeys(operation, ["effects", "failures", "name", "parameters", "resourceFlow", "returnType"], `operation ${operationIndex}`);
+                requireName(operation.name, operationNames, "operation");
+                requireName(operation.name, authorityOperationNames, "authority operation");
+                if (!dense(operation.parameters) || !dense(operation.failures) || !dense(operation.effects) ||
+                    operation.effects.length != 1 || operation.effects[0] != "host")
+                    invalid(`Operation '${operation.name}' has an invalid effect declaration.`);
+                const parameterNames = new Set();
+                const parameters = operation.parameters.map((parameter, parameterIndex) => {
+                    requirePlain(parameter, `parameter ${parameterIndex}`);
+                    requireKeys(parameter, ["name", "type"], `parameter ${parameterIndex}`);
+                    requireName(parameter.name, parameterNames, "parameter");
+                    return { name: parameter.name, type: normalizeValueType(parameter.type, resourceNames) };
+                });
+                const returnType = operation.returnType == "void" ? { kind: /** @type {const} */ ("TypeReference"), name: /** @type {const} */ ("void") } :
+                    normalizeValueType(operation.returnType, resourceNames);
+                const failureIds = operation.failures.map((name) => {
+                    if (typeof name != "string" || !failureNames.has(name))
+                        invalid(`Operation '${operation.name}' names an undeclared failure '${String(name)}'.`);
+                    return /** @type {string} */ (failureNames.get(name));
+                });
+                if (new Set(failureIds).size != failureIds.length)
+                    invalid(`Operation '${operation.name}' repeats a declared failure.`);
+                const resourceFlow = normalizeResourceFlow(operation.resourceFlow, resources, resourceNames, failureNames, parameters);
+                validateResourceOperation(operation.name, parameters, returnType, failureIds, resourceFlow);
+                return {
+                    effects: /** @type {const} */ (["host"]),
+                    failureIds,
+                    id: `${capabilityId}/operation:${operationIndex}`,
+                    kind: /** @type {const} */ ("EffectOperationDeclaration"),
+                    name: operation.name,
+                    parameters,
+                    resourceFlow,
+                    returnType
+                };
+            });
+            return {
+                authorityId: authorityInput.id,
+                failures,
+                id: capabilityId,
+                kind: /** @type {const} */ ("EffectCapabilityDeclaration"),
+                name: candidate.name,
+                operations,
+                resources
+            };
+        });
+        const result = /** @type {import("./types.js").CapabilityAuthority} */ ({
+            capabilities,
+            id: authorityInput.id,
+            schema: authoritySchema,
+            schemaVersion: 1,
+            ...(hasContractVersion ? { contractVersion: /** @type {string} */ (authorityInput.contractVersion) } : {})
+        });
+        deepFreeze(result);
+        createdAuthorities.add(result);
+        return result;
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        return invalid("Authority payload is malformed.");
+    }
+}
+/**
+ * Normalizes a strict multi-module schema-v2 authority.
+ * @param {import("./types.js").CapabilityAuthorityInput} authorityInput - Validated outer object candidate.
+ * @returns {Readonly<import("./types.js").CapabilityAuthority>} Normalized authority.
+ */
+function createCapabilityAuthorityV2(authorityInput) {
+    requireKeys(/** @type {Record<string, unknown>} */ (authorityInput), ["id", "modules", "schema", "schemaVersion"], "authority");
+    if (authorityInput.schema != authoritySchema || authorityInput.schemaVersion != 2 ||
+        typeof authorityInput.id != "string" || !authorityIdPattern.test(authorityInput.id) || !dense(authorityInput.modules)) {
+        invalid("Authority schema, version, identity, or module list is invalid.");
+    }
+    const identities = new Set();
+    const moduleInputs = authorityInput.modules.map((candidate, moduleIndex) => {
+        requirePlain(candidate, `module ${moduleIndex}`);
+        requireKeys(candidate, ["capabilities", "contractVersion", "identity"], `module ${moduleIndex}`);
+        if (typeof candidate.identity != "string" || !authorityIdPattern.test(candidate.identity) || identities.has(candidate.identity) ||
+            parseStdlibVersionRange(candidate.contractVersion) === null || !dense(candidate.capabilities)) {
+            invalid(`Authority module ${moduleIndex} is invalid or duplicate.`);
+        }
+        identities.add(candidate.identity);
+        return candidate;
+    });
+    const states = moduleInputs.map((moduleInput, moduleIndex) => {
+        const resourceNames = new Map();
+        const failureNames = new Map();
+        const capabilityNames = new Set();
+        const capabilities = moduleInput.capabilities.map((candidate, capabilityIndex) => {
+            requirePlain(candidate, `module ${moduleIndex} capability ${capabilityIndex}`);
+            requireKeys(candidate, ["failures", "name", "operations", "resources"], `module ${moduleIndex} capability ${capabilityIndex}`);
+            requireName(candidate.name, capabilityNames, "capability");
+            if (!dense(candidate.resources) || !dense(candidate.failures) || !dense(candidate.operations)) {
+                invalid(`Capability '${candidate.name}' requires ordered resource, failure, and operation arrays.`);
+            }
+            const capabilityId = `module:${moduleIndex}/capability:${capabilityIndex}`;
+            const resources = candidate.resources.map((resource, resourceIndex) => {
+                requireNamed(resource, resourceNames, "module resource");
+                const id = `${capabilityId}/resource:${resourceIndex}`;
+                resourceNames.set(resource.name, id);
+                return { id, kind: /** @type {const} */ ("EffectResourceDeclaration"), name: resource.name };
+            });
+            const failures = candidate.failures.map((failure, failureIndex) => {
+                requireNamed(failure, failureNames, "module failure");
+                const id = `${capabilityId}/failure:${failureIndex}`;
+                failureNames.set(failure.name, id);
+                return { id, kind: /** @type {const} */ ("EffectFailureDeclaration"), name: failure.name };
+            });
+            return { candidate, capabilityId, failures, resources };
+        });
+        return { capabilities, failureNames, identity: moduleInput.identity, moduleIndex, resourceNames,
+            contractVersion: moduleInput.contractVersion };
+    });
+    const operationNames = new Set();
+    const normalizedModules = states.map((state) => {
+        const capabilities = state.capabilities.map((capabilityState) => {
+            const localOperationNames = new Set();
+            const operations = capabilityState.candidate.operations.map((operation, operationIndex) => {
+                requirePlain(operation, `module ${state.moduleIndex} operation ${operationIndex}`);
+                requireKeys(operation, ["effects", "failures", "name", "parameters", "resourceFlow", "returnType"], `module ${state.moduleIndex} operation ${operationIndex}`);
+                requireName(operation.name, localOperationNames, "operation");
+                const qualifiedOperationName = `${state.identity}\u0000${operation.name}`;
+                if (operationNames.has(qualifiedOperationName))
+                    invalid(`Duplicate authority operation '${operation.name}'.`);
+                operationNames.add(qualifiedOperationName);
+                if (!dense(operation.parameters) || !dense(operation.failures) || !dense(operation.effects) ||
+                    operation.effects.length != 1 || operation.effects[0] != "host") {
+                    invalid(`Operation '${operation.name}' has an invalid effect declaration.`);
+                }
+                const parameterNames = new Set();
+                const parameters = operation.parameters.map((parameter, parameterIndex) => {
+                    requirePlain(parameter, `parameter ${parameterIndex}`);
+                    requireKeys(parameter, ["name", "type"], `parameter ${parameterIndex}`);
+                    requireName(parameter.name, parameterNames, "parameter");
+                    return { name: parameter.name, type: normalizeV2ValueType(parameter.type, state, states) };
+                });
+                const returnType = operation.returnType == "void"
+                    ? { kind: /** @type {const} */ ("TypeReference"), name: /** @type {const} */ ("void") }
+                    : normalizeV2ValueType(operation.returnType, state, states);
+                const failureIds = operation.failures.map((failure) => resolveV2Declaration(failure, state, states, "failure"));
+                if (new Set(failureIds).size != failureIds.length)
+                    invalid(`Operation '${operation.name}' repeats a declared failure.`);
+                const resourceFlow = normalizeV2ResourceFlow(operation.resourceFlow, parameters, state, states);
+                validateResourceOperation(operation.name, parameters, returnType, failureIds, resourceFlow);
+                return {
+                    effects: /** @type {const} */ (["host"]),
+                    failureIds,
+                    id: `${capabilityState.capabilityId}/operation:${operationIndex}`,
+                    kind: /** @type {const} */ ("EffectOperationDeclaration"),
+                    name: operation.name,
+                    parameters,
+                    resourceFlow,
+                    returnType
+                };
+            });
+            return {
+                authorityId: state.identity,
+                failures: capabilityState.failures,
+                id: capabilityState.capabilityId,
+                kind: /** @type {const} */ ("EffectCapabilityDeclaration"),
+                name: capabilityState.candidate.name,
+                operations,
+                resources: capabilityState.resources
+            };
+        });
+        return { capabilities, contractVersion: state.contractVersion, identity: state.identity };
+    });
+    const result = /** @type {import("./types.js").CapabilityAuthority} */ ({
+        capabilities: normalizedModules.flatMap(({ capabilities }) => capabilities),
+        id: authorityInput.id,
+        modules: normalizedModules,
+        schema: authoritySchema,
+        schemaVersion: 2
+    });
+    deepFreeze(result);
+    createdAuthorities.add(result);
+    return result;
+}
+/**
+ * Normalizes one schema-v2 value type.
+ * @param {unknown} candidate - Candidate type.
+ * @param {CapabilityAuthorityV2State} state - Current module state.
+ * @param {CapabilityAuthorityV2State[]} states - Complete authority states.
+ * @returns {import("./types.js").SemanticValueType} Normalized type.
+ */
+function normalizeV2ValueType(candidate, state, states) {
+    if (typeof candidate == "string" && scalarNames.has(candidate)) {
+        return { kind: /** @type {const} */ ("TypeReference"), name: /** @type {import("./types.js").SemanticTypeName} */ (candidate) };
+    }
+    requirePlain(candidate, "operation type");
+    if (candidate.kind == "OwnedResourceType") {
+        requireKeys(candidate, ["kind", "resource"], "owned resource type");
+        return { kind: /** @type {const} */ ("OwnedResourceType"), resourceId: resolveV2Declaration(candidate.resource, state, states, "resource") };
+    }
+    if (candidate.kind == "OptionalType") {
+        requireKeys(candidate, ["kind", "valueType"], "optional type");
+        if (typeof candidate.valueType != "string" || !scalarNames.has(candidate.valueType)) {
+            invalid("Capability optionals may contain only scalar values.");
+        }
+        return { kind: /** @type {const} */ ("OptionalType"), valueType: { kind: /** @type {const} */ ("TypeReference"),
+                name: /** @type {import("./types.js").SemanticTypeName} */ (candidate.valueType) } };
+    }
+    return invalid("Unsupported capability value type.");
+}
+/**
+ * Normalizes one schema-v2 resource transition.
+ * @param {unknown} candidate - Candidate transition.
+ * @param {import("./types.js").EffectParameter[]} parameters - Normalized parameters.
+ * @param {CapabilityAuthorityV2State} state - Current module state.
+ * @param {CapabilityAuthorityV2State[]} states - Complete authority states.
+ * @returns {import("./types.js").EffectResourceFlow} Normalized transition.
+ */
+function normalizeV2ResourceFlow(candidate, parameters, state, states) {
+    requirePlain(candidate, "resource flow");
+    if (candidate.kind == "none") {
+        requireKeys(candidate, ["kind"], "resource flow");
+        return { kind: /** @type {const} */ ("none") };
+    }
+    if (candidate.kind == "acquire") {
+        requireKeys(candidate, ["kind", "resource"], "acquisition flow");
+        return { kind: /** @type {const} */ ("acquire"), resourceId: resolveV2Declaration(candidate.resource, state, states, "resource") };
+    }
+    if (candidate.kind == "borrow" || candidate.kind == "close") {
+        requireKeys(candidate, ["kind", "parameterIndex", "terminalFailure"], `${candidate.kind} flow`);
+        const parameterIndex = /** @type {number} */ (candidate.parameterIndex);
+        if (!Number.isSafeInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= parameters.length ||
+            parameters[parameterIndex].type.kind != "OwnedResourceType")
+            invalid(`${candidate.kind} flow requires an owned resource parameter.`);
+        return { kind: /** @type {"borrow" | "close"} */ (candidate.kind), parameterIndex,
+            terminalFailureId: resolveV2Declaration(candidate.terminalFailure, state, states, "failure") };
+    }
+    return invalid("Unknown resource-flow kind.");
+}
+/**
+ * Resolves one local or qualified schema-v2 resource/failure reference.
+ * @param {unknown} candidate - Candidate reference.
+ * @param {CapabilityAuthorityV2State} state - Current module state.
+ * @param {CapabilityAuthorityV2State[]} states - Complete authority states.
+ * @param {"resource" | "failure"} kind - Declaration namespace.
+ * @returns {string} Normalized declaration identity.
+ */
+function resolveV2Declaration(candidate, state, states, kind) {
+    /** @type {CapabilityAuthorityV2State | undefined} */
+    let owner = state;
+    let name = candidate;
+    if (candidate !== null && typeof candidate == "object" && !Array.isArray(candidate)) {
+        requirePlain(candidate, `${kind} reference`);
+        requireKeys(candidate, ["module", "name"], `${kind} reference`);
+        if (typeof candidate.module != "string" || typeof candidate.name != "string")
+            invalid(`Invalid qualified ${kind} reference.`);
+        owner = states.find(({ identity }) => identity == candidate.module);
+        name = candidate.name;
+    }
+    if (!owner || typeof name != "string")
+        invalid(`Unknown ${kind} reference.`);
+    const declarations = kind == "resource" ? owner.resourceNames : owner.failureNames;
+    const id = declarations.get(name);
+    if (id === undefined)
+        invalid(`Unknown ${kind} '${owner.identity}.${name}'.`);
+    return id;
+}
+/**
+ * Normalizes an optional parse authority.
+ * @param {unknown} input - Optional caller input.
+ * @returns {Readonly<import("./types.js").CapabilityAuthority> | undefined} Authority or legacy absence.
+ */
+export function normalizeCapabilityAuthority(input) {
+    return input === undefined ? undefined : createCapabilityAuthority(input);
+}
+/**
+ * Finds one source-visible operation only when an ordinary source declaration did not win resolution.
+ * @param {readonly import("./types.js").EffectCapabilityDeclaration[]} capabilities - Authorized declarations.
+ * @param {string} name - Source spelling.
+ * @returns {{capability: import("./types.js").EffectCapabilityDeclaration, operation: import("./types.js").EffectOperationDeclaration} | undefined} Match.
+ */
+export function authorizedOperation(capabilities, name) {
+    for (const capability of capabilities) {
+        const operation = capability.operations.find((candidate) => candidate.name == name);
+        if (operation)
+            return { capability, operation };
+    }
+    return undefined;
+}
+/**
+ * Checks the bounded conformance operation namespace.
+ * @param {string} name - Candidate source name.
+ * @returns {boolean} Whether the name belongs to Task 034.
+ */
+export function isTask034OperationName(name) {
+    return ["probeAcquire", "probeClose", "probeEffect", "probeRead", "probeTrace"].includes(name);
+}
+/**
+ * Checks the exact built-in conformance capability identity.
+ * @param {readonly import("./types.js").EffectCapabilityDeclaration[]} capabilities - Candidate graph.
+ * @returns {boolean} Whether the graph has the supported identity and declaration order.
+ */
+export function isTask034ResourceProbe(capabilities) {
+    if (!dense(capabilities) || capabilities.length != 1)
+        return false;
+    const capability = capabilities[0];
+    if (!plainWithKeys(capability, ["authorityId", "failures", "id", "kind", "name", "operations", "resources"]) ||
+        capability.authorityId != "semantifold.task034.resource-probe" || capability.id != "capability:0" ||
+        capability.kind != "EffectCapabilityDeclaration" || capability.name != "ResourceProbe" ||
+        !dense(capability.resources) || !dense(capability.failures) || !dense(capability.operations) ||
+        capability.resources.length != 1 || capability.failures.length != 5 || capability.operations.length != 5)
+        return false;
+    if (!exactNamedDeclaration(capability.resources[0], "EffectResourceDeclaration", "capability:0/resource:0", "ProbeResource"))
+        return false;
+    const expectedFailures = ["ProbeOperationFailure", "ProbeAcquireFailure", "ProbeReadFailure", "ProbeCloseFailure", "ProbeResourceClosed"];
+    if (!capability.failures.every((failure, index) => exactNamedDeclaration(failure, "EffectFailureDeclaration", `capability:0/failure:${index}`, expectedFailures[index])))
+        return false;
+    return capability.operations.every((operation, index) => exactProbeOperation(operation, index, task034ProbeOperations[index]));
+}
+/**
+ * Checks one exact normalized declaration.
+ * @param {unknown} candidate - Candidate declaration.
+ * @param {string} kind - Expected kind.
+ * @param {string} id - Expected identity.
+ * @param {string} name - Expected source name.
+ * @returns {boolean} Whether the declaration is exact.
+ */
+function exactNamedDeclaration(candidate, kind, id, name) {
+    return plainWithKeys(candidate, ["id", "kind", "name"]) && candidate.kind == kind && candidate.id == id && candidate.name == name;
+}
+/**
+ * Checks one exact Task 034 conformance operation.
+ * @param {unknown} candidate - Candidate operation.
+ * @param {number} index - Expected operation index.
+ * @param {(typeof task034ProbeOperations)[number]} expected - Exact contract.
+ * @returns {boolean} Whether the operation matches the protected binding.
+ */
+function exactProbeOperation(candidate, index, expected) {
+    if (!plainWithKeys(candidate, ["effects", "failureIds", "id", "kind", "name", "parameters", "resourceFlow", "returnType"]) ||
+        candidate.kind != "EffectOperationDeclaration" || candidate.id != `capability:0/operation:${index}` ||
+        candidate.name != expected.name || !sameStringArray(candidate.effects, ["host"]) ||
+        !sameStringArray(candidate.failureIds, expected.failures) || !dense(candidate.parameters) ||
+        candidate.parameters.length != expected.parameters.length || !exactFlatObject(candidate.resourceFlow, expected.flow) ||
+        !exactProbeType(candidate.returnType, expected.returnType))
+        return false;
+    return candidate.parameters.every((parameter, parameterIndex) => plainWithKeys(parameter, ["name", "type"]) &&
+        parameter.name == expected.parameters[parameterIndex][0] && exactProbeType(parameter.type, expected.parameters[parameterIndex][1]));
+}
+/**
+ * Checks one exact normalized conformance type.
+ * @param {unknown} candidate - Candidate type.
+ * @param {string} expected - Compact expected type.
+ * @returns {boolean} Whether the type is exact.
+ */
+function exactProbeType(candidate, expected) {
+    if (expected == "resource") {
+        return plainWithKeys(candidate, ["kind", "resourceId"]) && candidate.kind == "OwnedResourceType" &&
+            candidate.resourceId == "capability:0/resource:0";
+    }
+    if (expected == "optional:string") {
+        return plainWithKeys(candidate, ["kind", "valueType"]) && candidate.kind == "OptionalType" &&
+            exactProbeType(candidate.valueType, "string");
+    }
+    return plainWithKeys(candidate, ["kind", "name"]) && candidate.kind == "TypeReference" && candidate.name == expected;
+}
+/**
+ * Checks an exact shallow object of primitive contract fields.
+ * @param {unknown} candidate - Candidate object.
+ * @param {Readonly<Record<string, unknown>>} expected - Expected fields.
+ * @returns {boolean} Whether all fields and values match.
+ */
+function exactFlatObject(candidate, expected) {
+    const keys = Object.keys(expected);
+    return plainWithKeys(candidate, keys) && keys.every((key) => candidate[key] == expected[key]);
+}
+/**
+ * Checks an exact dense string sequence.
+ * @param {unknown} candidate - Candidate sequence.
+ * @param {readonly string[]} expected - Expected strings.
+ * @returns {boolean} Whether order and values match.
+ */
+function sameStringArray(candidate, expected) {
+    return dense(candidate) && candidate.length == expected.length && candidate.every((value, index) => value == expected[index]);
+}
+/**
+ * Checks an ordinary object's exact own-key set.
+ * @param {unknown} candidate - Candidate object.
+ * @param {string[]} keys - Exact keys.
+ * @returns {candidate is Record<string, unknown>} Whether the object and fields are exact.
+ */
+function plainWithKeys(candidate, keys) {
+    return candidate !== null && typeof candidate == "object" && !Array.isArray(candidate) &&
+        Object.getPrototypeOf(candidate) == Object.prototype && Object.keys(candidate).sort().join(",") == [...keys].sort().join(",");
+}
+/**
+ * Normalizes one closed operation value type.
+ * @param {unknown} candidate - Raw value type.
+ * @param {Map<string, string>} resourceNames - Resource identities by name.
+ * @returns {import("./types.js").SemanticValueType} Normalized type.
+ */
+function normalizeValueType(candidate, resourceNames) {
+    if (typeof candidate == "string" && scalarNames.has(candidate)) {
+        return { kind: /** @type {const} */ ("TypeReference"), name: /** @type {import("./types.js").SemanticTypeName} */ (candidate) };
+    }
+    requirePlain(candidate, "operation type");
+    if (candidate.kind == "OwnedResourceType") {
+        requireKeys(candidate, ["kind", "resource"], "owned resource type");
+        if (typeof candidate.resource != "string" || !resourceNames.has(candidate.resource))
+            invalid(`Unknown owned resource '${String(candidate.resource)}'.`);
+        return { kind: /** @type {const} */ ("OwnedResourceType"), resourceId: /** @type {string} */ (resourceNames.get(candidate.resource)) };
+    }
+    if (candidate.kind == "OptionalType") {
+        requireKeys(candidate, ["kind", "valueType"], "optional type");
+        if (typeof candidate.valueType != "string" || !scalarNames.has(candidate.valueType))
+            invalid("Capability optionals may contain only scalar values.");
+        return { kind: /** @type {const} */ ("OptionalType"), valueType: { kind: /** @type {const} */ ("TypeReference"),
+                name: /** @type {import("./types.js").SemanticTypeName} */ (candidate.valueType) } };
+    }
+    return invalid("Unsupported capability value type.");
+}
+/**
+ * Normalizes one closed resource transition.
+ * @param {unknown} candidate - Raw transition.
+ * @param {import("./types.js").EffectResourceDeclaration[]} resources - Declared resources.
+ * @param {Map<string, string>} resourceNames - Resource identities by name.
+ * @param {Map<string, string>} failureNames - Failure identities by name.
+ * @param {import("./types.js").EffectParameter[]} parameters - Normalized ordered parameters.
+ * @returns {import("./types.js").EffectResourceFlow} Normalized flow.
+ */
+function normalizeResourceFlow(candidate, resources, resourceNames, failureNames, parameters) {
+    requirePlain(candidate, "resource flow");
+    if (candidate.kind == "none") {
+        requireKeys(candidate, ["kind"], "resource flow");
+        return { kind: /** @type {const} */ ("none") };
+    }
+    if (candidate.kind == "acquire") {
+        requireKeys(candidate, ["kind", "resource"], "acquisition flow");
+        if (typeof candidate.resource != "string" || !resourceNames.has(candidate.resource))
+            invalid("Acquisition names an undeclared resource.");
+        const resourceId = resourceNames.get(candidate.resource);
+        if (!resources.some(({ id }) => id == resourceId))
+            invalid("Acquisition resource identity is invalid.");
+        return { kind: /** @type {const} */ ("acquire"), resourceId: /** @type {string} */ (resourceId) };
+    }
+    if (candidate.kind == "borrow" || candidate.kind == "close") {
+        requireKeys(candidate, ["kind", "parameterIndex", "terminalFailure"], `${candidate.kind} flow`);
+        const parameterIndex = /** @type {number} */ (candidate.parameterIndex);
+        if (!Number.isSafeInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= parameters.length ||
+            parameters[parameterIndex].type.kind != "OwnedResourceType")
+            invalid(`${candidate.kind} flow requires an owned resource parameter.`);
+        if (typeof candidate.terminalFailure != "string" || !failureNames.has(candidate.terminalFailure)) {
+            invalid(`${candidate.kind} flow requires a declared terminal failure.`);
+        }
+        return { kind: /** @type {"borrow" | "close"} */ (candidate.kind), parameterIndex,
+            terminalFailureId: /** @type {string} */ (failureNames.get(candidate.terminalFailure)) };
+    }
+    return invalid("Unknown resource-flow kind.");
+}
+/**
+ * Requires every owned parameter/result to have one complete modeled transition.
+ * @param {string} name - Operation name.
+ * @param {import("./types.js").EffectParameter[]} parameters - Ordered parameters.
+ * @param {import("./types.js").SemanticFunctionReturnType} returnType - Operation result.
+ * @param {string[]} failureIds - Declared failure identities.
+ * @param {import("./types.js").EffectResourceFlow} resourceFlow - Declared transition.
+ * @returns {void}
+ */
+function validateResourceOperation(name, parameters, returnType, failureIds, resourceFlow) {
+    const ownedParameters = parameters.flatMap((parameter, index) => parameter.type.kind == "OwnedResourceType" ? [index] : []);
+    if (resourceFlow.kind == "none") {
+        if (ownedParameters.length > 0 || returnType.kind == "OwnedResourceType") {
+            invalid(`Operation '${name}' has an owned value without a resource transition.`);
+        }
+        return;
+    }
+    if (resourceFlow.kind == "acquire") {
+        if (ownedParameters.length > 0 || returnType.kind != "OwnedResourceType" || returnType.resourceId != resourceFlow.resourceId) {
+            invalid(`Operation '${name}' acquisition result does not match its resource transition.`);
+        }
+        return;
+    }
+    if (ownedParameters.length != 1 || ownedParameters[0] != resourceFlow.parameterIndex ||
+        returnType.kind == "OwnedResourceType" || !failureIds.includes(resourceFlow.terminalFailureId)) {
+        invalid(`Operation '${name}' borrow/close transition is incomplete.`);
+    }
+}
+/**
+ * Validates one single-field named declaration.
+ * @param {unknown} candidate - Raw declaration.
+ * @param {Map<string, string | undefined>} names - Already-declared names.
+ * @param {string} subject - Diagnostic subject.
+ * @returns {void}
+ */
+function requireNamed(candidate, names, subject) {
+    requirePlain(candidate, subject);
+    requireKeys(candidate, ["name"], subject);
+    if (typeof candidate.name != "string" || !declarationNamePattern.test(candidate.name) || names.has(candidate.name)) {
+        invalid(`Duplicate or invalid ${subject} name.`);
+    }
+    names.set(candidate.name, undefined);
+}
+/**
+ * Validates and reserves one declaration name.
+ * @param {unknown} name - Candidate name.
+ * @param {Set<string>} names - Already-declared names.
+ * @param {string} subject - Diagnostic subject.
+ * @returns {void}
+ */
+function requireName(name, names, subject) {
+    if (typeof name != "string" || !declarationNamePattern.test(name) || names.has(name))
+        invalid(`Duplicate or invalid ${subject} name.`);
+    names.add(name);
+}
+/**
+ * Requires an ordinary object.
+ * @param {unknown} value - Candidate value.
+ * @param {string} subject - Diagnostic subject.
+ * @returns {asserts value is Record<string, unknown>} Asserts an ordinary object.
+ */
+function requirePlain(value, subject) {
+    if (!value || typeof value != "object" || Array.isArray(value) || Object.getPrototypeOf(value) != Object.prototype)
+        invalid(`Invalid ${subject} object.`);
+}
+/**
+ * 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(","))
+        invalid(`Invalid ${subject} fields.`);
+}
+/**
+ * Checks an ordered dense array.
+ * @param {unknown} value - Candidate array.
+ * @returns {value is unknown[]} Whether the value is dense.
+ */
+function dense(value) {
+    return Array.isArray(value) && value.every((_item, index) => Object.hasOwn(value, index));
+}
+/**
+ * Recursively freezes a detached authority graph.
+ * @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);
+}
+/**
+ * Raises one stable authority diagnostic.
+ * @param {string} message - Diagnostic message.
+ * @returns {never} Always throws.
+ */
+function invalid(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_CAPABILITY_AUTHORITY", language: "capability", message });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../../src/semantic/capabilities.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {SemantifoldDiagnostic} from \"../diagnostic.js\"\nimport {parseStdlibVersionRange} from \"./stdlib.js\"\n\nconst authoritySchema = \"SemantifoldCapabilityAuthority\"\nconst authorityIdPattern = /^[a-z][a-z0-9.-]*$/u\nconst declarationNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/u\nconst scalarNames = new Set([\"boolean\", \"integer\", \"string\"])\nconst createdAuthorities = new WeakSet()\n/**\n * @typedef CapabilityAuthorityV2State\n * @property {{candidate: import(\"./types.js\").CapabilityDeclarationInput, capabilityId: string, failures: import(\"./types.js\").EffectFailureDeclaration[], resources: import(\"./types.js\").EffectResourceDeclaration[]}[]} capabilities - Prepared capability declarations.\n * @property {Map<string, string | undefined>} failureNames - Module-local failures.\n * @property {string} identity - Canonical module identity.\n * @property {number} moduleIndex - Stable module position.\n * @property {Map<string, string | undefined>} resourceNames - Module-local resources.\n * @property {string} contractVersion - Canonical contract range.\n */\nconst task034ProbeOperations = Object.freeze([\n  Object.freeze({failures: Object.freeze([\"capability:0/failure:0\"]), flow: Object.freeze({kind: \"none\"}),\n    name: \"probeEffect\", parameters: Object.freeze([[\"label\", \"string\"], [\"value\", \"integer\"], [\"fail\", \"boolean\"]]),\n    returnType: \"integer\"}),\n  Object.freeze({failures: Object.freeze([\"capability:0/failure:1\"]),\n    flow: Object.freeze({kind: \"acquire\", resourceId: \"capability:0/resource:0\"}), name: \"probeAcquire\",\n    parameters: Object.freeze([[\"fail\", \"boolean\"]]), returnType: \"resource\"}),\n  Object.freeze({failures: Object.freeze([\"capability:0/failure:2\", \"capability:0/failure:4\"]),\n    flow: Object.freeze({kind: \"borrow\", parameterIndex: 0, terminalFailureId: \"capability:0/failure:4\"}), name: \"probeRead\",\n    parameters: Object.freeze([[\"resource\", \"resource\"], [\"fail\", \"boolean\"]]), returnType: \"optional:string\"}),\n  Object.freeze({failures: Object.freeze([\"capability:0/failure:3\", \"capability:0/failure:4\"]),\n    flow: Object.freeze({kind: \"close\", parameterIndex: 0, terminalFailureId: \"capability:0/failure:4\"}), name: \"probeClose\",\n    parameters: Object.freeze([[\"resource\", \"resource\"], [\"fail\", \"boolean\"]]), returnType: \"void\"}),\n  Object.freeze({failures: Object.freeze([]), flow: Object.freeze({kind: \"none\"}), name: \"probeTrace\",\n    parameters: Object.freeze([]), returnType: \"string\"})\n])\n\n/**\n * Creates an immutable, detached compiler-authority descriptor.\n * @param {unknown} input - Untrusted authority input.\n * @returns {Readonly<import(\"./types.js\").CapabilityAuthority>} Normalized authority.\n */\nexport function createCapabilityAuthority(input) {\n  try {\n    if (createdAuthorities.has(/** @type {object} */ (input))) return /** @type {Readonly<import(\"./types.js\").CapabilityAuthority>} */ (input)\n    requirePlain(input, \"authority\")\n    const authorityInput = /** @type {import(\"./types.js\").CapabilityAuthorityInput} */ (input)\n\n    if (authorityInput.schemaVersion == 2) return createCapabilityAuthorityV2(authorityInput)\n    const hasContractVersion = Object.hasOwn(authorityInput, \"contractVersion\")\n\n    requireKeys(authorityInput, hasContractVersion\n      ? [\"capabilities\", \"contractVersion\", \"id\", \"schema\", \"schemaVersion\"]\n      : [\"capabilities\", \"id\", \"schema\", \"schemaVersion\"], \"authority\")\n    if (hasContractVersion && parseStdlibVersionRange(authorityInput.contractVersion) === null) {\n      throw new SemantifoldDiagnostic({\n        code: \"STDLIB_VERSION_MALFORMED\",\n        language: \"capability\",\n        message: \"Capability authority contractVersion is not a canonical stdlib version range.\"\n      })\n    }\n    if (authorityInput.schema != authoritySchema || authorityInput.schemaVersion != 1 || typeof authorityInput.id != \"string\" ||\n      !authorityIdPattern.test(authorityInput.id) || !dense(authorityInput.capabilities)) invalid(\"Authority schema, version, identity, or capability list is invalid.\")\n\n    const capabilityNames = new Set()\n    const authorityResourceNames = new Set()\n    const authorityFailureNames = new Set()\n    const authorityOperationNames = new Set()\n    const capabilities = authorityInput.capabilities.map((candidate, capabilityIndex) => {\n      requirePlain(candidate, `capability ${capabilityIndex}`)\n      requireKeys(candidate, [\"failures\", \"name\", \"operations\", \"resources\"], `capability ${capabilityIndex}`)\n      requireName(candidate.name, capabilityNames, \"capability\")\n      if (!dense(candidate.resources) || !dense(candidate.failures) || !dense(candidate.operations)) {\n        invalid(`Capability '${candidate.name}' requires ordered resource, failure, and operation arrays.`)\n      }\n      const capabilityId = `capability:${capabilityIndex}`\n      const resourceNames = new Map()\n      const resources = candidate.resources.map((resource, resourceIndex) => {\n        requireNamed(resource, resourceNames, \"resource\")\n        requireName(resource.name, authorityResourceNames, \"authority resource\")\n        const id = `${capabilityId}/resource:${resourceIndex}`\n        resourceNames.set(resource.name, id)\n        return {id, kind: /** @type {const} */ (\"EffectResourceDeclaration\"), name: resource.name}\n      })\n      const failureNames = new Map()\n      const failures = candidate.failures.map((failure, failureIndex) => {\n        requireNamed(failure, failureNames, \"failure\")\n        requireName(failure.name, authorityFailureNames, \"authority failure\")\n        const id = `${capabilityId}/failure:${failureIndex}`\n        failureNames.set(failure.name, id)\n        return {id, kind: /** @type {const} */ (\"EffectFailureDeclaration\"), name: failure.name}\n      })\n      const operationNames = new Set()\n      const operations = candidate.operations.map((operation, operationIndex) => {\n        requirePlain(operation, `operation ${operationIndex}`)\n        requireKeys(operation, [\"effects\", \"failures\", \"name\", \"parameters\", \"resourceFlow\", \"returnType\"], `operation ${operationIndex}`)\n        requireName(operation.name, operationNames, \"operation\")\n        requireName(operation.name, authorityOperationNames, \"authority operation\")\n        if (!dense(operation.parameters) || !dense(operation.failures) || !dense(operation.effects) ||\n          operation.effects.length != 1 || operation.effects[0] != \"host\") invalid(`Operation '${operation.name}' has an invalid effect declaration.`)\n        const parameterNames = new Set()\n        const parameters = operation.parameters.map((parameter, parameterIndex) => {\n          requirePlain(parameter, `parameter ${parameterIndex}`)\n          requireKeys(parameter, [\"name\", \"type\"], `parameter ${parameterIndex}`)\n          requireName(parameter.name, parameterNames, \"parameter\")\n          return {name: parameter.name, type: normalizeValueType(parameter.type, resourceNames)}\n        })\n        const returnType = operation.returnType == \"void\" ? {kind: /** @type {const} */ (\"TypeReference\"), name: /** @type {const} */ (\"void\")} :\n          normalizeValueType(operation.returnType, resourceNames)\n        const failureIds = operation.failures.map((name) => {\n          if (typeof name != \"string\" || !failureNames.has(name)) invalid(`Operation '${operation.name}' names an undeclared failure '${String(name)}'.`)\n          return /** @type {string} */ (failureNames.get(name))\n        })\n        if (new Set(failureIds).size != failureIds.length) invalid(`Operation '${operation.name}' repeats a declared failure.`)\n        const resourceFlow = normalizeResourceFlow(operation.resourceFlow, resources, resourceNames, failureNames, parameters)\n\n        validateResourceOperation(operation.name, parameters, returnType, failureIds, resourceFlow)\n\n        return {\n          effects: /** @type {const} */ ([\"host\"]),\n          failureIds,\n          id: `${capabilityId}/operation:${operationIndex}`,\n          kind: /** @type {const} */ (\"EffectOperationDeclaration\"),\n          name: operation.name,\n          parameters,\n          resourceFlow,\n          returnType\n        }\n      })\n\n      return {\n        authorityId: authorityInput.id,\n        failures,\n        id: capabilityId,\n        kind: /** @type {const} */ (\"EffectCapabilityDeclaration\"),\n        name: candidate.name,\n        operations,\n        resources\n      }\n    })\n    const result = /** @type {import(\"./types.js\").CapabilityAuthority} */ ({\n      capabilities,\n      id: authorityInput.id,\n      schema: authoritySchema,\n      schemaVersion: 1,\n      ...(hasContractVersion ? {contractVersion: /** @type {string} */ (authorityInput.contractVersion)} : {})\n    })\n\n    deepFreeze(result)\n    createdAuthorities.add(result)\n    return result\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) throw error\n    return invalid(\"Authority payload is malformed.\")\n  }\n}\n\n/**\n * Normalizes a strict multi-module schema-v2 authority.\n * @param {import(\"./types.js\").CapabilityAuthorityInput} authorityInput - Validated outer object candidate.\n * @returns {Readonly<import(\"./types.js\").CapabilityAuthority>} Normalized authority.\n */\nfunction createCapabilityAuthorityV2(authorityInput) {\n  requireKeys(/** @type {Record<string, unknown>} */ (authorityInput), [\"id\", \"modules\", \"schema\", \"schemaVersion\"], \"authority\")\n  if (authorityInput.schema != authoritySchema || authorityInput.schemaVersion != 2 ||\n    typeof authorityInput.id != \"string\" || !authorityIdPattern.test(authorityInput.id) || !dense(authorityInput.modules)) {\n    invalid(\"Authority schema, version, identity, or module list is invalid.\")\n  }\n  const identities = new Set()\n  const moduleInputs = authorityInput.modules.map((candidate, moduleIndex) => {\n    requirePlain(candidate, `module ${moduleIndex}`)\n    requireKeys(candidate, [\"capabilities\", \"contractVersion\", \"identity\"], `module ${moduleIndex}`)\n    if (typeof candidate.identity != \"string\" || !authorityIdPattern.test(candidate.identity) || identities.has(candidate.identity) ||\n      parseStdlibVersionRange(candidate.contractVersion) === null || !dense(candidate.capabilities)) {\n      invalid(`Authority module ${moduleIndex} is invalid or duplicate.`)\n    }\n    identities.add(candidate.identity)\n    return candidate\n  })\n  const states = moduleInputs.map((moduleInput, moduleIndex) => {\n    const resourceNames = new Map()\n    const failureNames = new Map()\n    const capabilityNames = new Set()\n    const capabilities = moduleInput.capabilities.map((candidate, capabilityIndex) => {\n      requirePlain(candidate, `module ${moduleIndex} capability ${capabilityIndex}`)\n      requireKeys(candidate, [\"failures\", \"name\", \"operations\", \"resources\"], `module ${moduleIndex} capability ${capabilityIndex}`)\n      requireName(candidate.name, capabilityNames, \"capability\")\n      if (!dense(candidate.resources) || !dense(candidate.failures) || !dense(candidate.operations)) {\n        invalid(`Capability '${candidate.name}' requires ordered resource, failure, and operation arrays.`)\n      }\n      const capabilityId = `module:${moduleIndex}/capability:${capabilityIndex}`\n      const resources = candidate.resources.map((resource, resourceIndex) => {\n        requireNamed(resource, resourceNames, \"module resource\")\n        const id = `${capabilityId}/resource:${resourceIndex}`\n\n        resourceNames.set(resource.name, id)\n        return {id, kind: /** @type {const} */ (\"EffectResourceDeclaration\"), name: resource.name}\n      })\n      const failures = candidate.failures.map((failure, failureIndex) => {\n        requireNamed(failure, failureNames, \"module failure\")\n        const id = `${capabilityId}/failure:${failureIndex}`\n\n        failureNames.set(failure.name, id)\n        return {id, kind: /** @type {const} */ (\"EffectFailureDeclaration\"), name: failure.name}\n      })\n\n      return {candidate, capabilityId, failures, resources}\n    })\n\n    return {capabilities, failureNames, identity: moduleInput.identity, moduleIndex, resourceNames,\n      contractVersion: moduleInput.contractVersion}\n  })\n  const operationNames = new Set()\n  const normalizedModules = states.map((state) => {\n    const capabilities = state.capabilities.map((capabilityState) => {\n      const localOperationNames = new Set()\n      const operations = capabilityState.candidate.operations.map((operation, operationIndex) => {\n        requirePlain(operation, `module ${state.moduleIndex} operation ${operationIndex}`)\n        requireKeys(operation, [\"effects\", \"failures\", \"name\", \"parameters\", \"resourceFlow\", \"returnType\"],\n          `module ${state.moduleIndex} operation ${operationIndex}`)\n        requireName(operation.name, localOperationNames, \"operation\")\n        const qualifiedOperationName = `${state.identity}\\u0000${operation.name}`\n\n        if (operationNames.has(qualifiedOperationName)) invalid(`Duplicate authority operation '${operation.name}'.`)\n        operationNames.add(qualifiedOperationName)\n        if (!dense(operation.parameters) || !dense(operation.failures) || !dense(operation.effects) ||\n          operation.effects.length != 1 || operation.effects[0] != \"host\") {\n          invalid(`Operation '${operation.name}' has an invalid effect declaration.`)\n        }\n        const parameterNames = new Set()\n        const parameters = operation.parameters.map((parameter, parameterIndex) => {\n          requirePlain(parameter, `parameter ${parameterIndex}`)\n          requireKeys(parameter, [\"name\", \"type\"], `parameter ${parameterIndex}`)\n          requireName(parameter.name, parameterNames, \"parameter\")\n          return {name: parameter.name, type: normalizeV2ValueType(parameter.type, state, states)}\n        })\n        const returnType = operation.returnType == \"void\"\n          ? {kind: /** @type {const} */ (\"TypeReference\"), name: /** @type {const} */ (\"void\")}\n          : normalizeV2ValueType(operation.returnType, state, states)\n        const failureIds = operation.failures.map((failure) => resolveV2Declaration(failure, state, states, \"failure\"))\n\n        if (new Set(failureIds).size != failureIds.length) invalid(`Operation '${operation.name}' repeats a declared failure.`)\n        const resourceFlow = normalizeV2ResourceFlow(operation.resourceFlow, parameters, state, states)\n\n        validateResourceOperation(operation.name, parameters, returnType, failureIds, resourceFlow)\n        return {\n          effects: /** @type {const} */ ([\"host\"]),\n          failureIds,\n          id: `${capabilityState.capabilityId}/operation:${operationIndex}`,\n          kind: /** @type {const} */ (\"EffectOperationDeclaration\"),\n          name: operation.name,\n          parameters,\n          resourceFlow,\n          returnType\n        }\n      })\n\n      return {\n        authorityId: state.identity,\n        failures: capabilityState.failures,\n        id: capabilityState.capabilityId,\n        kind: /** @type {const} */ (\"EffectCapabilityDeclaration\"),\n        name: capabilityState.candidate.name,\n        operations,\n        resources: capabilityState.resources\n      }\n    })\n\n    return {capabilities, contractVersion: state.contractVersion, identity: state.identity}\n  })\n  const result = /** @type {import(\"./types.js\").CapabilityAuthority} */ ({\n    capabilities: normalizedModules.flatMap(({capabilities}) => capabilities),\n    id: authorityInput.id,\n    modules: normalizedModules,\n    schema: authoritySchema,\n    schemaVersion: 2\n  })\n\n  deepFreeze(result)\n  createdAuthorities.add(result)\n  return result\n}\n\n/**\n * Normalizes one schema-v2 value type.\n * @param {unknown} candidate - Candidate type.\n * @param {CapabilityAuthorityV2State} state - Current module state.\n * @param {CapabilityAuthorityV2State[]} states - Complete authority states.\n * @returns {import(\"./types.js\").SemanticValueType} Normalized type.\n */\nfunction normalizeV2ValueType(candidate, state, states) {\n  if (typeof candidate == \"string\" && scalarNames.has(candidate)) {\n    return {kind: /** @type {const} */ (\"TypeReference\"), name: /** @type {import(\"./types.js\").SemanticTypeName} */ (candidate)}\n  }\n  requirePlain(candidate, \"operation type\")\n  if (candidate.kind == \"OwnedResourceType\") {\n    requireKeys(candidate, [\"kind\", \"resource\"], \"owned resource type\")\n    return {kind: /** @type {const} */ (\"OwnedResourceType\"), resourceId: resolveV2Declaration(candidate.resource, state, states, \"resource\")}\n  }\n  if (candidate.kind == \"OptionalType\") {\n    requireKeys(candidate, [\"kind\", \"valueType\"], \"optional type\")\n    if (typeof candidate.valueType != \"string\" || !scalarNames.has(candidate.valueType)) {\n      invalid(\"Capability optionals may contain only scalar values.\")\n    }\n    return {kind: /** @type {const} */ (\"OptionalType\"), valueType: {kind: /** @type {const} */ (\"TypeReference\"),\n      name: /** @type {import(\"./types.js\").SemanticTypeName} */ (candidate.valueType)}}\n  }\n  return invalid(\"Unsupported capability value type.\")\n}\n\n/**\n * Normalizes one schema-v2 resource transition.\n * @param {unknown} candidate - Candidate transition.\n * @param {import(\"./types.js\").EffectParameter[]} parameters - Normalized parameters.\n * @param {CapabilityAuthorityV2State} state - Current module state.\n * @param {CapabilityAuthorityV2State[]} states - Complete authority states.\n * @returns {import(\"./types.js\").EffectResourceFlow} Normalized transition.\n */\nfunction normalizeV2ResourceFlow(candidate, parameters, state, states) {\n  requirePlain(candidate, \"resource flow\")\n  if (candidate.kind == \"none\") {\n    requireKeys(candidate, [\"kind\"], \"resource flow\")\n    return {kind: /** @type {const} */ (\"none\")}\n  }\n  if (candidate.kind == \"acquire\") {\n    requireKeys(candidate, [\"kind\", \"resource\"], \"acquisition flow\")\n    return {kind: /** @type {const} */ (\"acquire\"), resourceId: resolveV2Declaration(candidate.resource, state, states, \"resource\")}\n  }\n  if (candidate.kind == \"borrow\" || candidate.kind == \"close\") {\n    requireKeys(candidate, [\"kind\", \"parameterIndex\", \"terminalFailure\"], `${candidate.kind} flow`)\n    const parameterIndex = /** @type {number} */ (candidate.parameterIndex)\n\n    if (!Number.isSafeInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= parameters.length ||\n      parameters[parameterIndex].type.kind != \"OwnedResourceType\") invalid(`${candidate.kind} flow requires an owned resource parameter.`)\n    return {kind: /** @type {\"borrow\" | \"close\"} */ (candidate.kind), parameterIndex,\n      terminalFailureId: resolveV2Declaration(candidate.terminalFailure, state, states, \"failure\")}\n  }\n  return invalid(\"Unknown resource-flow kind.\")\n}\n\n/**\n * Resolves one local or qualified schema-v2 resource/failure reference.\n * @param {unknown} candidate - Candidate reference.\n * @param {CapabilityAuthorityV2State} state - Current module state.\n * @param {CapabilityAuthorityV2State[]} states - Complete authority states.\n * @param {\"resource\" | \"failure\"} kind - Declaration namespace.\n * @returns {string} Normalized declaration identity.\n */\nfunction resolveV2Declaration(candidate, state, states, kind) {\n  /** @type {CapabilityAuthorityV2State | undefined} */\n  let owner = state\n  let name = candidate\n\n  if (candidate !== null && typeof candidate == \"object\" && !Array.isArray(candidate)) {\n    requirePlain(candidate, `${kind} reference`)\n    requireKeys(candidate, [\"module\", \"name\"], `${kind} reference`)\n    if (typeof candidate.module != \"string\" || typeof candidate.name != \"string\") invalid(`Invalid qualified ${kind} reference.`)\n    owner = states.find(({identity}) => identity == candidate.module)\n    name = candidate.name\n  }\n  if (!owner || typeof name != \"string\") invalid(`Unknown ${kind} reference.`)\n  const declarations = kind == \"resource\" ? owner.resourceNames : owner.failureNames\n  const id = declarations.get(name)\n\n  if (id === undefined) invalid(`Unknown ${kind} '${owner.identity}.${name}'.`)\n  return id\n}\n\n/**\n * Normalizes an optional parse authority.\n * @param {unknown} input - Optional caller input.\n * @returns {Readonly<import(\"./types.js\").CapabilityAuthority> | undefined} Authority or legacy absence.\n */\nexport function normalizeCapabilityAuthority(input) {\n  return input === undefined ? undefined : createCapabilityAuthority(input)\n}\n\n/**\n * Finds one source-visible operation only when an ordinary source declaration did not win resolution.\n * @param {readonly import(\"./types.js\").EffectCapabilityDeclaration[]} capabilities - Authorized declarations.\n * @param {string} name - Source spelling.\n * @returns {{capability: import(\"./types.js\").EffectCapabilityDeclaration, operation: import(\"./types.js\").EffectOperationDeclaration} | undefined} Match.\n */\nexport function authorizedOperation(capabilities, name) {\n  for (const capability of capabilities) {\n    const operation = capability.operations.find((candidate) => candidate.name == name)\n    if (operation) return {capability, operation}\n  }\n  return undefined\n}\n\n/**\n * Checks the bounded conformance operation namespace.\n * @param {string} name - Candidate source name.\n * @returns {boolean} Whether the name belongs to Task 034.\n */\nexport function isTask034OperationName(name) {\n  return [\"probeAcquire\", \"probeClose\", \"probeEffect\", \"probeRead\", \"probeTrace\"].includes(name)\n}\n\n/**\n * Checks the exact built-in conformance capability identity.\n * @param {readonly import(\"./types.js\").EffectCapabilityDeclaration[]} capabilities - Candidate graph.\n * @returns {boolean} Whether the graph has the supported identity and declaration order.\n */\nexport function isTask034ResourceProbe(capabilities) {\n  if (!dense(capabilities) || capabilities.length != 1) return false\n  const capability = capabilities[0]\n\n  if (!plainWithKeys(capability, [\"authorityId\", \"failures\", \"id\", \"kind\", \"name\", \"operations\", \"resources\"]) ||\n    capability.authorityId != \"semantifold.task034.resource-probe\" || capability.id != \"capability:0\" ||\n    capability.kind != \"EffectCapabilityDeclaration\" || capability.name != \"ResourceProbe\" ||\n    !dense(capability.resources) || !dense(capability.failures) || !dense(capability.operations) ||\n    capability.resources.length != 1 || capability.failures.length != 5 || capability.operations.length != 5) return false\n  if (!exactNamedDeclaration(capability.resources[0], \"EffectResourceDeclaration\", \"capability:0/resource:0\", \"ProbeResource\")) return false\n  const expectedFailures = [\"ProbeOperationFailure\", \"ProbeAcquireFailure\", \"ProbeReadFailure\", \"ProbeCloseFailure\", \"ProbeResourceClosed\"]\n\n  if (!capability.failures.every((failure, index) =>\n    exactNamedDeclaration(failure, \"EffectFailureDeclaration\", `capability:0/failure:${index}`, expectedFailures[index]))) return false\n  return capability.operations.every((operation, index) => exactProbeOperation(operation, index, task034ProbeOperations[index]))\n}\n\n/**\n * Checks one exact normalized declaration.\n * @param {unknown} candidate - Candidate declaration.\n * @param {string} kind - Expected kind.\n * @param {string} id - Expected identity.\n * @param {string} name - Expected source name.\n * @returns {boolean} Whether the declaration is exact.\n */\nfunction exactNamedDeclaration(candidate, kind, id, name) {\n  return plainWithKeys(candidate, [\"id\", \"kind\", \"name\"]) && candidate.kind == kind && candidate.id == id && candidate.name == name\n}\n\n/**\n * Checks one exact Task 034 conformance operation.\n * @param {unknown} candidate - Candidate operation.\n * @param {number} index - Expected operation index.\n * @param {(typeof task034ProbeOperations)[number]} expected - Exact contract.\n * @returns {boolean} Whether the operation matches the protected binding.\n */\nfunction exactProbeOperation(candidate, index, expected) {\n  if (!plainWithKeys(candidate, [\"effects\", \"failureIds\", \"id\", \"kind\", \"name\", \"parameters\", \"resourceFlow\", \"returnType\"]) ||\n    candidate.kind != \"EffectOperationDeclaration\" || candidate.id != `capability:0/operation:${index}` ||\n    candidate.name != expected.name || !sameStringArray(candidate.effects, [\"host\"]) ||\n    !sameStringArray(candidate.failureIds, expected.failures) || !dense(candidate.parameters) ||\n    candidate.parameters.length != expected.parameters.length || !exactFlatObject(candidate.resourceFlow, expected.flow) ||\n    !exactProbeType(candidate.returnType, expected.returnType)) return false\n  return candidate.parameters.every((parameter, parameterIndex) => plainWithKeys(parameter, [\"name\", \"type\"]) &&\n    parameter.name == expected.parameters[parameterIndex][0] && exactProbeType(parameter.type, expected.parameters[parameterIndex][1]))\n}\n\n/**\n * Checks one exact normalized conformance type.\n * @param {unknown} candidate - Candidate type.\n * @param {string} expected - Compact expected type.\n * @returns {boolean} Whether the type is exact.\n */\nfunction exactProbeType(candidate, expected) {\n  if (expected == \"resource\") {\n    return plainWithKeys(candidate, [\"kind\", \"resourceId\"]) && candidate.kind == \"OwnedResourceType\" &&\n      candidate.resourceId == \"capability:0/resource:0\"\n  }\n  if (expected == \"optional:string\") {\n    return plainWithKeys(candidate, [\"kind\", \"valueType\"]) && candidate.kind == \"OptionalType\" &&\n      exactProbeType(candidate.valueType, \"string\")\n  }\n  return plainWithKeys(candidate, [\"kind\", \"name\"]) && candidate.kind == \"TypeReference\" && candidate.name == expected\n}\n\n/**\n * Checks an exact shallow object of primitive contract fields.\n * @param {unknown} candidate - Candidate object.\n * @param {Readonly<Record<string, unknown>>} expected - Expected fields.\n * @returns {boolean} Whether all fields and values match.\n */\nfunction exactFlatObject(candidate, expected) {\n  const keys = Object.keys(expected)\n  return plainWithKeys(candidate, keys) && keys.every((key) => candidate[key] == expected[key])\n}\n\n/**\n * Checks an exact dense string sequence.\n * @param {unknown} candidate - Candidate sequence.\n * @param {readonly string[]} expected - Expected strings.\n * @returns {boolean} Whether order and values match.\n */\nfunction sameStringArray(candidate, expected) {\n  return dense(candidate) && candidate.length == expected.length && candidate.every((value, index) => value == expected[index])\n}\n\n/**\n * Checks an ordinary object's exact own-key set.\n * @param {unknown} candidate - Candidate object.\n * @param {string[]} keys - Exact keys.\n * @returns {candidate is Record<string, unknown>} Whether the object and fields are exact.\n */\nfunction plainWithKeys(candidate, keys) {\n  return candidate !== null && typeof candidate == \"object\" && !Array.isArray(candidate) &&\n    Object.getPrototypeOf(candidate) == Object.prototype && Object.keys(candidate).sort().join(\",\") == [...keys].sort().join(\",\")\n}\n\n/**\n * Normalizes one closed operation value type.\n * @param {unknown} candidate - Raw value type.\n * @param {Map<string, string>} resourceNames - Resource identities by name.\n * @returns {import(\"./types.js\").SemanticValueType} Normalized type.\n */\nfunction normalizeValueType(candidate, resourceNames) {\n  if (typeof candidate == \"string\" && scalarNames.has(candidate)) {\n    return {kind: /** @type {const} */ (\"TypeReference\"), name: /** @type {import(\"./types.js\").SemanticTypeName} */ (candidate)}\n  }\n  requirePlain(candidate, \"operation type\")\n  if (candidate.kind == \"OwnedResourceType\") {\n    requireKeys(candidate, [\"kind\", \"resource\"], \"owned resource type\")\n    if (typeof candidate.resource != \"string\" || !resourceNames.has(candidate.resource)) invalid(`Unknown owned resource '${String(candidate.resource)}'.`)\n    return {kind: /** @type {const} */ (\"OwnedResourceType\"), resourceId: /** @type {string} */ (resourceNames.get(candidate.resource))}\n  }\n  if (candidate.kind == \"OptionalType\") {\n    requireKeys(candidate, [\"kind\", \"valueType\"], \"optional type\")\n    if (typeof candidate.valueType != \"string\" || !scalarNames.has(candidate.valueType)) invalid(\"Capability optionals may contain only scalar values.\")\n    return {kind: /** @type {const} */ (\"OptionalType\"), valueType: {kind: /** @type {const} */ (\"TypeReference\"),\n      name: /** @type {import(\"./types.js\").SemanticTypeName} */ (candidate.valueType)}}\n  }\n  return invalid(\"Unsupported capability value type.\")\n}\n\n/**\n * Normalizes one closed resource transition.\n * @param {unknown} candidate - Raw transition.\n * @param {import(\"./types.js\").EffectResourceDeclaration[]} resources - Declared resources.\n * @param {Map<string, string>} resourceNames - Resource identities by name.\n * @param {Map<string, string>} failureNames - Failure identities by name.\n * @param {import(\"./types.js\").EffectParameter[]} parameters - Normalized ordered parameters.\n * @returns {import(\"./types.js\").EffectResourceFlow} Normalized flow.\n */\nfunction normalizeResourceFlow(candidate, resources, resourceNames, failureNames, parameters) {\n  requirePlain(candidate, \"resource flow\")\n  if (candidate.kind == \"none\") {\n    requireKeys(candidate, [\"kind\"], \"resource flow\")\n    return {kind: /** @type {const} */ (\"none\")}\n  }\n  if (candidate.kind == \"acquire\") {\n    requireKeys(candidate, [\"kind\", \"resource\"], \"acquisition flow\")\n    if (typeof candidate.resource != \"string\" || !resourceNames.has(candidate.resource)) invalid(\"Acquisition names an undeclared resource.\")\n    const resourceId = resourceNames.get(candidate.resource)\n    if (!resources.some(({id}) => id == resourceId)) invalid(\"Acquisition resource identity is invalid.\")\n    return {kind: /** @type {const} */ (\"acquire\"), resourceId: /** @type {string} */ (resourceId)}\n  }\n  if (candidate.kind == \"borrow\" || candidate.kind == \"close\") {\n    requireKeys(candidate, [\"kind\", \"parameterIndex\", \"terminalFailure\"], `${candidate.kind} flow`)\n    const parameterIndex = /** @type {number} */ (candidate.parameterIndex)\n    if (!Number.isSafeInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= parameters.length ||\n      parameters[parameterIndex].type.kind != \"OwnedResourceType\") invalid(`${candidate.kind} flow requires an owned resource parameter.`)\n    if (typeof candidate.terminalFailure != \"string\" || !failureNames.has(candidate.terminalFailure)) {\n      invalid(`${candidate.kind} flow requires a declared terminal failure.`)\n    }\n    return {kind: /** @type {\"borrow\" | \"close\"} */ (candidate.kind), parameterIndex,\n      terminalFailureId: /** @type {string} */ (failureNames.get(candidate.terminalFailure))}\n  }\n  return invalid(\"Unknown resource-flow kind.\")\n}\n\n/**\n * Requires every owned parameter/result to have one complete modeled transition.\n * @param {string} name - Operation name.\n * @param {import(\"./types.js\").EffectParameter[]} parameters - Ordered parameters.\n * @param {import(\"./types.js\").SemanticFunctionReturnType} returnType - Operation result.\n * @param {string[]} failureIds - Declared failure identities.\n * @param {import(\"./types.js\").EffectResourceFlow} resourceFlow - Declared transition.\n * @returns {void}\n */\nfunction validateResourceOperation(name, parameters, returnType, failureIds, resourceFlow) {\n  const ownedParameters = parameters.flatMap((parameter, index) => parameter.type.kind == \"OwnedResourceType\" ? [index] : [])\n\n  if (resourceFlow.kind == \"none\") {\n    if (ownedParameters.length > 0 || returnType.kind == \"OwnedResourceType\") {\n      invalid(`Operation '${name}' has an owned value without a resource transition.`)\n    }\n    return\n  }\n  if (resourceFlow.kind == \"acquire\") {\n    if (ownedParameters.length > 0 || returnType.kind != \"OwnedResourceType\" || returnType.resourceId != resourceFlow.resourceId) {\n      invalid(`Operation '${name}' acquisition result does not match its resource transition.`)\n    }\n    return\n  }\n  if (ownedParameters.length != 1 || ownedParameters[0] != resourceFlow.parameterIndex ||\n    returnType.kind == \"OwnedResourceType\" || !failureIds.includes(resourceFlow.terminalFailureId)) {\n    invalid(`Operation '${name}' borrow/close transition is incomplete.`)\n  }\n}\n\n/**\n * Validates one single-field named declaration.\n * @param {unknown} candidate - Raw declaration.\n * @param {Map<string, string | undefined>} names - Already-declared names.\n * @param {string} subject - Diagnostic subject.\n * @returns {void}\n */\nfunction requireNamed(candidate, names, subject) {\n  requirePlain(candidate, subject)\n  requireKeys(candidate, [\"name\"], subject)\n  if (typeof candidate.name != \"string\" || !declarationNamePattern.test(candidate.name) || names.has(candidate.name)) {\n    invalid(`Duplicate or invalid ${subject} name.`)\n  }\n  names.set(candidate.name, undefined)\n}\n\n/**\n * Validates and reserves one declaration name.\n * @param {unknown} name - Candidate name.\n * @param {Set<string>} names - Already-declared names.\n * @param {string} subject - Diagnostic subject.\n * @returns {void}\n */\nfunction requireName(name, names, subject) {\n  if (typeof name != \"string\" || !declarationNamePattern.test(name) || names.has(name)) invalid(`Duplicate or invalid ${subject} name.`)\n  names.add(name)\n}\n\n/**\n * Requires an ordinary object.\n * @param {unknown} value - Candidate value.\n * @param {string} subject - Diagnostic subject.\n * @returns {asserts value is Record<string, unknown>} Asserts an ordinary object.\n */\nfunction requirePlain(value, subject) {\n  if (!value || typeof value != \"object\" || Array.isArray(value) || Object.getPrototypeOf(value) != Object.prototype) invalid(`Invalid ${subject} object.`)\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(\",\")) invalid(`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 dense(value) {\n  return Array.isArray(value) && value.every((_item, index) => Object.hasOwn(value, index))\n}\n\n/**\n * Recursively freezes a detached authority graph.\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/**\n * Raises one stable authority diagnostic.\n * @param {string} message - Diagnostic message.\n * @returns {never} Always throws.\n */\nfunction invalid(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_CAPABILITY_AUTHORITY\", language: \"capability\", message})\n}\n"]}