@abot-ai/runtime 1.0.0

package/dist/src/runtime/orchestration/worker-capabilities/binding.js

@@ -0,0 +1,625 @@
+import { isRoleCapabilityId, hasRoleCallCapabilityAuthority, parseRoleCallWorkerCapabilityScope, projectRoleCallDependencyResults, } from "../role-calls/index.js";
+import { WORKER_CAPABILITY_COUNT_MAX, WORKER_CAPABILITY_CONTROL_COUNT_MAX, WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH, WORKER_CAPABILITY_INTENT_MAX_LENGTH, WORKER_CAPABILITY_SUMMARY_MAX_LENGTH, } from "./contracts.js";
+import { normalizeWorkerCapabilityControlsSchema, validateWorkerCapabilityControls, } from "./controls.js";
+import { partitionWorkerCapabilityControlsSchema } from "./selection-controls.js";
+import { traceWorkerCapabilityBindingCreated, traceWorkerCapabilityBindingRejected, traceWorkerCapabilitySelectionRejected, traceWorkerCapabilitySelectionResolved, } from "./diagnostics.js";
+import { executeBoundWorkerCapability, executeBoundWorkerCapabilityBatch, } from "./execution.js";
+import { classifyRuntimeErrorType } from "../../observability/error-type.js";
+import { isToolCatalogGroupId } from "../../../capabilities/tool-types.js";
+import { projectWorkerCapabilityCatalogGroups, projectWorkerCapabilityScope, WorkerCapabilityScopeError, } from "./scope.js";
+const SINGLE_CAPABILITY_LOOKUP_ISSUES = Object.freeze({
+    invalid: "capability_id_invalid",
+    outOfScope: "capability_out_of_scope",
+    unavailable: "capability_unavailable",
+});
+const BATCH_CAPABILITY_LOOKUP_ISSUES = Object.freeze({
+    invalid: "batch_capability_id_invalid",
+    outOfScope: "batch_capability_out_of_scope",
+    unavailable: "batch_capability_unavailable",
+});
+export function createRoleCapabilityBinding(params) {
+    const boundCall = copyCall(params.call);
+    const diagnosticScope = parseRoleCallWorkerCapabilityScope(boundCall.workerCapabilityScope);
+    const emptyDiagnostic = {
+        requestId: params.requestId,
+        call: boundCall,
+        capabilityIds: Object.freeze([]),
+        scopeMode: boundCall.workerCapabilityScope === undefined ? "full" : "catalog_groups",
+        scopeCatalogGroupIds: diagnosticScope?.catalogGroupIds ?? Object.freeze([]),
+        knownCatalogGroupCount: 0,
+        fullCapabilityCount: 0,
+        filteredCapabilityCount: 0,
+    };
+    const executionFreshness = boundCall.parentCallId === null
+        ? normalizeExecutionFreshness(params.executionFreshness)
+        : undefined;
+    if (params.executionFreshness !== undefined && !executionFreshness) {
+        traceWorkerCapabilityBindingRejected(emptyDiagnostic, "execution_freshness_invalid");
+        throw rejection("execution_freshness_invalid");
+    }
+    let initialHead;
+    try {
+        initialHead = params.ledger.current();
+    }
+    catch {
+        traceWorkerCapabilityBindingRejected(emptyDiagnostic, "current_call_read_failed");
+        throw rejection("current_call_read_failed");
+    }
+    const authoritativeCall = initialHead.state.calls.find((call) => call.callId === boundCall.callId);
+    const authorityIssue = initialHead.state.requestId !== params.requestId
+        ? "request_id_mismatch"
+        : initialHead.state.activeCallId !== boundCall.callId
+            ? "call_not_current"
+            : authoritativeCall
+                ? validateExecutionCall(boundCall, authoritativeCall, initialHead)
+                : "current_call_unavailable";
+    if (authorityIssue) {
+        traceWorkerCapabilityBindingRejected(emptyDiagnostic, authorityIssue);
+        throw rejection(authorityIssue);
+    }
+    let dependencyResults;
+    try {
+        dependencyResults = bindDependencyResults(initialHead, authoritativeCall, params.dependencyResults);
+    }
+    catch {
+        traceWorkerCapabilityBindingRejected(emptyDiagnostic, "dependency_results_invalid");
+        throw rejection("dependency_results_invalid");
+    }
+    if (!Array.isArray(params.adapters) ||
+        params.adapters.length > WORKER_CAPABILITY_COUNT_MAX) {
+        traceWorkerCapabilityBindingRejected(emptyDiagnostic, "capability_count_invalid");
+        throw rejection("capability_count_invalid");
+    }
+    const boundAdapters = [];
+    const seenCapabilityIds = new Set();
+    for (const adapter of params.adapters) {
+        const normalized = normalizeAdapter(adapter);
+        if (!normalized.ok) {
+            traceWorkerCapabilityBindingRejected({
+                ...emptyDiagnostic,
+                capabilityIds: Object.freeze([...seenCapabilityIds]),
+            }, normalized.issueCode);
+            throw rejection(normalized.issueCode);
+        }
+        if (seenCapabilityIds.has(normalized.value.descriptor.capabilityId)) {
+            traceWorkerCapabilityBindingRejected({
+                ...emptyDiagnostic,
+                capabilityIds: Object.freeze([...seenCapabilityIds]),
+            }, "duplicate_capability_id");
+            throw rejection("duplicate_capability_id");
+        }
+        seenCapabilityIds.add(normalized.value.descriptor.capabilityId);
+        boundAdapters.push(normalized.value);
+    }
+    const knownCatalogGroups = projectWorkerCapabilityCatalogGroups(boundAdapters.map((adapter) => adapter.descriptor));
+    let capabilityScope;
+    try {
+        capabilityScope = projectWorkerCapabilityScope({
+            entries: boundAdapters,
+            scope: boundCall.workerCapabilityScope,
+            descriptorOf: (adapter) => adapter.descriptor,
+        });
+    }
+    catch (error) {
+        const issueCode = error instanceof WorkerCapabilityScopeError
+            ? error.issueCode
+            : "capability_scope_projection_invalid";
+        traceWorkerCapabilityBindingRejected({
+            ...emptyDiagnostic,
+            capabilityIds: Object.freeze([...seenCapabilityIds]),
+            knownCatalogGroupCount: knownCatalogGroups.length,
+            fullCapabilityCount: boundAdapters.length,
+        }, issueCode);
+        throw rejection(issueCode);
+    }
+    const scopedAdapters = capabilityScope.entries;
+    const byCapabilityId = new Map(scopedAdapters.map((adapter) => [adapter.descriptor.capabilityId, adapter]));
+    const capabilities = Object.freeze(scopedAdapters.map((adapter) => adapter.descriptor));
+    const diagnostic = Object.freeze({
+        requestId: params.requestId,
+        call: boundCall,
+        capabilityIds: capabilityScope.filteredCapabilityIds,
+        scopeMode: capabilityScope.mode,
+        scopeCatalogGroupIds: capabilityScope.catalogGroupIds,
+        knownCatalogGroupCount: capabilityScope.knownCatalogGroupIds.length,
+        fullCapabilityCount: capabilityScope.fullCapabilityIds.length,
+        filteredCapabilityCount: capabilityScope.filteredCapabilityIds.length,
+    });
+    traceWorkerCapabilityBindingCreated(diagnostic);
+    const session = new BoundCapabilitySession({
+        requestId: params.requestId,
+        context: params.context,
+        boundCall,
+        ledger: params.ledger,
+        capabilities,
+        byCapabilityId,
+        diagnostic,
+        capabilityScope,
+        dependencyResults,
+        ...(executionFreshness ? { executionFreshness } : {}),
+    });
+    return session.toBinding();
+}
+/**
+ * Immutable request/call-scoped capability facade. Authoritative ledger state
+ * is deliberately resolved per invocation and is never stored on the session.
+ */
+class BoundCapabilitySession {
+    #requestId;
+    #context;
+    #boundCall;
+    #ledger;
+    #capabilities;
+    #byCapabilityId;
+    #diagnostic;
+    #capabilityScope;
+    #executionFreshness;
+    #dependencyResults;
+    constructor(params) {
+        this.#requestId = params.requestId;
+        this.#context = params.context;
+        this.#boundCall = params.boundCall;
+        this.#ledger = params.ledger;
+        this.#capabilities = params.capabilities;
+        this.#byCapabilityId = params.byCapabilityId;
+        this.#diagnostic = params.diagnostic;
+        this.#capabilityScope = params.capabilityScope;
+        this.#dependencyResults = params.dependencyResults;
+        this.#executionFreshness = params.executionFreshness;
+    }
+    toBinding() {
+        return Object.freeze({
+            requestId: this.#requestId,
+            ledger: this.#ledger,
+            callId: this.#boundCall.callId,
+            invocationAttempt: this.#boundCall.activationCount,
+            capabilities: this.#capabilities,
+            execute: async (input) => this.#execute(input),
+            executeBatch: async (input) => this.#executeBatch(input),
+        });
+    }
+    async #execute(input) {
+        const { currentHead, currentCall } = this.#resolveLiveCall({
+            ...(isValidCapabilityId(input.capabilityId)
+                ? { attemptedCapabilityId: input.capabilityId }
+                : {}),
+        });
+        const invocation = this.#prepareSingleInvocation(input);
+        return executeBoundWorkerCapability({
+            context: this.#context,
+            call: currentCall,
+            currentHead,
+            ledger: this.#ledger,
+            ...invocation,
+            diagnostic: this.#diagnostic,
+            capabilityScope: this.#capabilityScope,
+            ...(this.#dependencyResults.length > 0
+                ? { dependencyResults: this.#dependencyResults }
+                : {}),
+            ...(this.#executionFreshness
+                ? { executionFreshness: this.#executionFreshness }
+                : {}),
+        });
+    }
+    async #executeBatch(input) {
+        const { currentHead, currentCall } = this.#resolveLiveCall();
+        if (!Array.isArray(input.invocations) || input.invocations.length < 2) {
+            traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                issueCode: "batch_size_invalid",
+            });
+            throw rejection("batch_size_invalid");
+        }
+        if (currentHead.state.capabilityExecutions.length + input.invocations.length >
+            currentHead.policy.limits.maxCapabilityExecutions) {
+            traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                issueCode: "capability_execution_limit_exceeded",
+            });
+            throw rejection("capability_execution_limit_exceeded");
+        }
+        const invocations = this.#prepareBatchInvocations(input.invocations);
+        return executeBoundWorkerCapabilityBatch({
+            context: this.#context,
+            call: currentCall,
+            currentHead,
+            ledger: this.#ledger,
+            invocations,
+            diagnostic: this.#diagnostic,
+            capabilityScope: this.#capabilityScope,
+            ...(this.#dependencyResults.length > 0
+                ? { dependencyResults: this.#dependencyResults }
+                : {}),
+            ...(this.#executionFreshness
+                ? { executionFreshness: this.#executionFreshness }
+                : {}),
+        });
+    }
+    #resolveLiveCall(params = {}) {
+        let currentHead;
+        let currentCall;
+        try {
+            currentHead = this.#ledger.current();
+            if (currentHead.state.requestId !== this.#requestId) {
+                traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                    issueCode: "request_id_mismatch",
+                });
+                throw rejection("request_id_mismatch");
+            }
+            if (currentHead.state.activeCallId !== this.#boundCall.callId) {
+                traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                    issueCode: "call_not_current",
+                });
+                throw rejection("call_not_current");
+            }
+            currentCall = currentHead.state.calls.find((call) => call.callId === this.#boundCall.callId);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith("worker_capability_rejected:")) {
+                throw error;
+            }
+            traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                issueCode: "current_call_read_failed",
+                errorType: classifyRuntimeErrorType(error),
+            });
+            throw rejection("current_call_read_failed");
+        }
+        if (!currentCall) {
+            traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                issueCode: "current_call_unavailable",
+            });
+            throw rejection("current_call_unavailable");
+        }
+        const bindingIssue = validateExecutionCall(this.#boundCall, currentCall, currentHead);
+        if (bindingIssue) {
+            traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                issueCode: bindingIssue,
+                attemptedCallId: currentCall.callId,
+                attemptedInvocationAttempt: currentCall.activationCount,
+                ...(params.attemptedCapabilityId
+                    ? { capabilityId: params.attemptedCapabilityId }
+                    : {}),
+            });
+            throw rejection(bindingIssue);
+        }
+        return { currentHead, currentCall };
+    }
+    #prepareSingleInvocation(input) {
+        const adapter = this.#resolveAvailableAdapter(input.capabilityId, SINGLE_CAPABILITY_LOOKUP_ISSUES);
+        const intent = normalizeIntent(input.intent);
+        if (!intent.ok) {
+            traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                issueCode: intent.issueCode,
+                capabilityId: input.capabilityId,
+            });
+            throw rejection(intent.issueCode);
+        }
+        const controls = validateWorkerCapabilityControls(adapter.descriptor.controls, input.controls);
+        if (!controls.ok) {
+            traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                issueCode: controls.issueCode,
+                capabilityId: input.capabilityId,
+            });
+            throw rejection(controls.issueCode);
+        }
+        this.#traceSelectionResolved(adapter, intent.value, controls.value);
+        return {
+            adapter,
+            intent: intent.value,
+            controls: controls.value,
+        };
+    }
+    #prepareBatchInvocations(candidates) {
+        const invocations = [];
+        for (let index = 0; index < candidates.length; index += 1) {
+            const candidate = candidates[index];
+            const adapter = this.#resolveAvailableAdapter(candidate.capabilityId, BATCH_CAPABILITY_LOOKUP_ISSUES);
+            if (adapter.descriptor.effect !== "observation") {
+                traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                    issueCode: "batch_effect_invalid",
+                    capabilityId: candidate.capabilityId,
+                });
+                throw rejection("batch_effect_invalid");
+            }
+            const intent = normalizeIntent(candidate.intent);
+            if (!intent.ok) {
+                const issueCode = `batch_${intent.issueCode}`;
+                traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                    issueCode,
+                    capabilityId: candidate.capabilityId,
+                });
+                throw rejection(issueCode);
+            }
+            const controls = validateWorkerCapabilityControls(adapter.descriptor.controls, candidate.controls);
+            if (!controls.ok) {
+                const issueCode = `batch_${controls.issueCode}`;
+                traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                    issueCode,
+                    capabilityId: candidate.capabilityId,
+                });
+                throw rejection(issueCode);
+            }
+            this.#traceSelectionResolved(adapter, intent.value, controls.value);
+            invocations.push({
+                adapter,
+                intent: intent.value,
+                controls: controls.value,
+            });
+        }
+        return Object.freeze(invocations);
+    }
+    #resolveAvailableAdapter(capabilityId, issueCodes) {
+        if (!isValidCapabilityId(capabilityId)) {
+            traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                issueCode: issueCodes.invalid,
+            });
+            throw rejection(issueCodes.invalid);
+        }
+        const adapter = this.#byCapabilityId.get(capabilityId);
+        if (!adapter) {
+            const issueCode = this.#capabilityScope.fullCapabilityIds.includes(capabilityId)
+                ? issueCodes.outOfScope
+                : issueCodes.unavailable;
+            traceWorkerCapabilitySelectionRejected(this.#diagnostic, {
+                issueCode,
+                capabilityId,
+            });
+            throw rejection(issueCode);
+        }
+        return adapter;
+    }
+    #traceSelectionResolved(adapter, intent, controls) {
+        traceWorkerCapabilitySelectionResolved(this.#diagnostic, adapter.descriptor, intent.length, Object.keys(controls).length);
+    }
+}
+function normalizeExecutionFreshness(input) {
+    if (input === undefined)
+        return undefined;
+    if (typeof input !== "object" ||
+        input === null ||
+        typeof input.isCurrent !== "function" ||
+        typeof input.token !== "object" ||
+        input.token === null ||
+        input.token.kind !== "request_steering_v1" ||
+        !Number.isSafeInteger(input.token.version) ||
+        input.token.version < 0 ||
+        !Array.isArray(input.token.updates) ||
+        input.token.updates.length !== input.token.version ||
+        input.token.updates.some((update, index) => typeof update !== "object" ||
+            update === null ||
+            update.sequence !== index + 1 ||
+            typeof update.text !== "string" ||
+            update.text.trim().length === 0)) {
+        return undefined;
+    }
+    const source = input;
+    return Object.freeze({
+        token: Object.freeze({
+            kind: "request_steering_v1",
+            version: input.token.version,
+            updates: Object.freeze(input.token.updates.map(({ sequence, text }) => Object.freeze({ sequence, text }))),
+        }),
+        isCurrent: () => source.isCurrent(),
+    });
+}
+function validateActiveRoleCapabilityCall(head, call) {
+    if (call.status !== "active" ||
+        !Number.isInteger(call.activationCount) ||
+        call.activationCount < 1 ||
+        call.resultRef !== null ||
+        !hasRoleCallCapabilityAuthority(head.policy.authority, head.state.rootCallId, call)) {
+        return "worker_call_invalid";
+    }
+    const isRoot = call.callId === head.state.rootCallId && call.parentCallId === null;
+    if ((isRoot && (call.depth !== 0 || call.objective !== null)) ||
+        (!isRoot &&
+            (call.parentCallId === null ||
+                call.depth < 1 ||
+                call.objective === null ||
+                call.objective.trim().length === 0))) {
+        return "worker_call_invalid";
+    }
+    return null;
+}
+function validateExecutionCall(boundCall, currentCall, head) {
+    const activeIssue = validateActiveRoleCapabilityCall(head, currentCall);
+    if (activeIssue)
+        return activeIssue;
+    if (currentCall.callId !== boundCall.callId)
+        return "call_id_mismatch";
+    if (currentCall.roleId !== boundCall.roleId)
+        return "worker_call_invalid";
+    if (currentCall.parentCallId !== boundCall.parentCallId) {
+        return "parent_call_id_mismatch";
+    }
+    if (currentCall.depth !== boundCall.depth)
+        return "call_depth_mismatch";
+    if (currentCall.activationCount !== boundCall.activationCount) {
+        return "invocation_attempt_mismatch";
+    }
+    if (currentCall.workingDirectory !== boundCall.workingDirectory) {
+        return "working_directory_mismatch";
+    }
+    if (!sameWorkerCapabilityScope(currentCall.workerCapabilityScope, boundCall.workerCapabilityScope)) {
+        return "worker_capability_scope_mismatch";
+    }
+    return null;
+}
+/** Compatibility name for the existing Worker contract and focused callers. */
+export const createWorkerCapabilityBinding = createRoleCapabilityBinding;
+function bindDependencyResults(head, call, supplied) {
+    const canonical = projectRoleCallDependencyResults(head, call);
+    if (supplied === undefined)
+        return canonical;
+    if (!Array.isArray(supplied) ||
+        !Object.isFrozen(supplied) ||
+        supplied.length !== canonical.length ||
+        supplied.some((result, index) => {
+            const expected = canonical[index];
+            return (!Object.isFrozen(result) ||
+                !expected ||
+                result.resultRef !== expected.resultRef ||
+                result.producerCallId !== expected.producerCallId ||
+                result.roleId !== expected.roleId ||
+                result.outcome !== expected.outcome ||
+                result.summary !== expected.summary);
+        })) {
+        throw new Error("worker_dependency_results_invalid");
+    }
+    return Object.freeze([...supplied]);
+}
+function sameWorkerCapabilityScope(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return (left.catalogGroupIds.length === right.catalogGroupIds.length &&
+        left.catalogGroupIds.every((groupId, index) => groupId === right.catalogGroupIds[index]));
+}
+function normalizeAdapter(adapter) {
+    if (typeof adapter !== "object" ||
+        adapter === null ||
+        Array.isArray(adapter)) {
+        return { ok: false, issueCode: "adapter_invalid" };
+    }
+    const descriptor = normalizeDescriptor(adapter.descriptor);
+    if (!descriptor.ok)
+        return descriptor;
+    if (typeof adapter.execute !== "function") {
+        return { ok: false, issueCode: "adapter_execute_missing" };
+    }
+    return {
+        ok: true,
+        value: Object.freeze({
+            descriptor: descriptor.value,
+            execute: adapter.execute,
+        }),
+    };
+}
+function normalizeDescriptor(descriptor) {
+    if (typeof descriptor !== "object" ||
+        descriptor === null ||
+        Array.isArray(descriptor)) {
+        return { ok: false, issueCode: "descriptor_invalid" };
+    }
+    if (!isValidCapabilityId(descriptor.capabilityId)) {
+        return { ok: false, issueCode: "descriptor_capability_id_invalid" };
+    }
+    if (typeof descriptor.summary !== "string" ||
+        descriptor.summary.trim().length === 0 ||
+        descriptor.summary.length > WORKER_CAPABILITY_SUMMARY_MAX_LENGTH) {
+        return { ok: false, issueCode: "descriptor_summary_invalid" };
+    }
+    if (!isWorkerCapabilityEffect(descriptor.effect)) {
+        return { ok: false, issueCode: "descriptor_effect_invalid" };
+    }
+    const controls = normalizeWorkerCapabilityControlsSchema(descriptor.controls);
+    if (!controls.ok) {
+        return {
+            ok: false,
+            issueCode: `descriptor_${controls.issueCode}`,
+        };
+    }
+    const runtimePathControlIds = normalizeRuntimePathControlIds(controls.value, descriptor.runtimePathControlIds);
+    if (!runtimePathControlIds.ok) {
+        return {
+            ok: false,
+            issueCode: `descriptor_${runtimePathControlIds.issueCode}`,
+        };
+    }
+    const controlsPartition = partitionWorkerCapabilityControlsSchema(controls.value, descriptor.selectionControlIds);
+    if (!controlsPartition.ok) {
+        return {
+            ok: false,
+            issueCode: `descriptor_${controlsPartition.issueCode}`,
+        };
+    }
+    if (descriptor.controlsRefinement !== undefined &&
+        descriptor.controlsRefinement !== "mechanical_when_complete") {
+        return { ok: false, issueCode: "descriptor_controls_refinement_invalid" };
+    }
+    const catalogGroups = descriptor.catalogGroups ?? ["other"];
+    if (!Array.isArray(catalogGroups) ||
+        catalogGroups.length === 0 ||
+        new Set(catalogGroups).size !== catalogGroups.length ||
+        catalogGroups.some((catalogGroup) => !isToolCatalogGroupId(catalogGroup))) {
+        return { ok: false, issueCode: "descriptor_catalog_groups_invalid" };
+    }
+    return {
+        ok: true,
+        value: Object.freeze({
+            capabilityId: descriptor.capabilityId,
+            summary: descriptor.summary.trim(),
+            effect: descriptor.effect,
+            controls: controls.value,
+            ...(runtimePathControlIds.value.length > 0
+                ? { runtimePathControlIds: runtimePathControlIds.value }
+                : {}),
+            ...(controlsPartition.value.selectionControlIds.length > 0
+                ? {
+                    selectionControlIds: controlsPartition.value.selectionControlIds,
+                }
+                : {}),
+            ...(descriptor.controlsRefinement
+                ? { controlsRefinement: descriptor.controlsRefinement }
+                : {}),
+            catalogGroups: Object.freeze([...catalogGroups]),
+        }),
+    };
+}
+function normalizeRuntimePathControlIds(controls, input) {
+    if (input === undefined) {
+        return { ok: true, value: Object.freeze([]) };
+    }
+    if (!Array.isArray(input) ||
+        input.length === 0 ||
+        input.length > WORKER_CAPABILITY_CONTROL_COUNT_MAX) {
+        return { ok: false, issueCode: "runtime_path_control_ids_invalid" };
+    }
+    const seen = new Set();
+    for (const controlId of input) {
+        if (typeof controlId !== "string" ||
+            controlId.length === 0 ||
+            controlId.length > WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH ||
+            controlId.trim() !== controlId) {
+            return { ok: false, issueCode: "runtime_path_control_ids_invalid" };
+        }
+        if (seen.has(controlId)) {
+            return { ok: false, issueCode: "runtime_path_control_ids_duplicate" };
+        }
+        if (!Object.hasOwn(controls.properties, controlId)) {
+            return { ok: false, issueCode: "runtime_path_control_unknown" };
+        }
+        seen.add(controlId);
+    }
+    return { ok: true, value: Object.freeze([...input]) };
+}
+function normalizeIntent(input) {
+    if (typeof input !== "string" ||
+        input.trim().length === 0 ||
+        input.length > WORKER_CAPABILITY_INTENT_MAX_LENGTH) {
+        return { ok: false, issueCode: "intent_invalid" };
+    }
+    return { ok: true, value: input.trim() };
+}
+function isValidCapabilityId(input) {
+    return isRoleCapabilityId(input);
+}
+function isWorkerCapabilityEffect(input) {
+    return input === "observation" || input === "mutation" || input === "mixed";
+}
+function rejection(issueCode) {
+    return new Error(`worker_capability_rejected:${issueCode}`);
+}
+function copyCall(call) {
+    return Object.freeze({
+        ...call,
+        childCallIds: Object.freeze([...call.childCallIds]),
+        ...(call.workerCapabilityScope
+            ? {
+                workerCapabilityScope: Object.freeze({
+                    catalogGroupIds: Object.freeze([
+                        ...call.workerCapabilityScope.catalogGroupIds,
+                    ]),
+                }),
+            }
+            : {}),
+    });
+}