@abot-ai/runtime 1.0.0

package/dist/src/runtime/orchestration/role-executors/activation/loop.js

@@ -0,0 +1,245 @@
+import { isRuntimeDelegateRoleId } from "../../roles.js";
+import { traceRoleExecutorCompleted, traceRoleExecutorContinued, traceRoleExecutorContinuationRejected, traceRoleExecutorFailed, traceRoleExecutorInitialStateRejected, traceRoleExecutorResolved, traceRoleExecutorResultRejected, traceRoleExecutorStarted, traceRoleExecutorStateRejected, traceRoleExecutorUnavailable, } from "../diagnostics.js";
+import { requireResumedCallerCall } from "../child-invocation/state-validation.js";
+import { createAttemptDiagnostic, createDiagnostic, } from "../shared/diagnostic-context.js";
+import { continuationError, readLedgerOrReject, stateError, } from "../shared/runtime-invariants.js";
+import { normalizeRoleExecutorActivationResult } from "./result-normalization.js";
+import { resolveCurrentCall, validateCapabilityContinuation, } from "./state-validation.js";
+export class RoleActivationLoop {
+    params;
+    expectedCall;
+    continuationReference;
+    constructor(params) {
+        this.params = params;
+        this.expectedCall = params.input.call;
+    }
+    async run() {
+        const { executor, initialHead, call } = this.resolveInitialActivation();
+        this.expectedCall = call;
+        const maximumTurns = initialHead.policy.limits.maxCalls +
+            initialHead.policy.limits.maxCapabilityExecutions +
+            1;
+        for (let turnCount = 1; turnCount <= maximumTurns; turnCount += 1) {
+            const activation = this.requireCurrentActivation(turnCount);
+            const terminal = await this.runActivation(executor, activation, turnCount);
+            if (terminal)
+                return terminal;
+        }
+        const exhaustedDiagnostic = createDiagnostic({
+            requestId: this.params.input.requestId,
+            call: this.expectedCall,
+            registeredRoleIds: this.params.registeredRoleIds,
+        });
+        traceRoleExecutorStateRejected(exhaustedDiagnostic, "continuation_limit_exceeded", maximumTurns);
+        throw stateError("continuation_limit_exceeded");
+    }
+    resolveInitialActivation() {
+        const { input, registeredRoleIds, executorByRoleId } = this.params;
+        const attemptedRoleId = isRuntimeDelegateRoleId(input.call.roleId)
+            ? input.call.roleId
+            : undefined;
+        const initialAttemptDiagnostic = createAttemptDiagnostic({
+            requestId: input.requestId,
+            callId: input.call.callId,
+            ...(attemptedRoleId ? { attemptedRoleId } : {}),
+            registeredRoleIds,
+        });
+        if (!isRuntimeDelegateRoleId(input.call.roleId)) {
+            traceRoleExecutorUnavailable(initialAttemptDiagnostic);
+            throw new Error("role_executor_not_registered");
+        }
+        const executor = executorByRoleId.get(input.call.roleId);
+        if (!executor) {
+            traceRoleExecutorUnavailable(initialAttemptDiagnostic);
+            throw new Error("role_executor_not_registered");
+        }
+        let initialHead;
+        try {
+            initialHead = input.ledger.current();
+        }
+        catch {
+            traceRoleExecutorInitialStateRejected(initialAttemptDiagnostic, "ledger_read_failed");
+            throw stateError("ledger_read_failed");
+        }
+        const initialAuthority = resolveCurrentCall({
+            head: initialHead,
+            requestId: input.requestId,
+            expectedCall: input.call,
+        });
+        if (!initialAuthority.ok) {
+            traceRoleExecutorInitialStateRejected(initialAttemptDiagnostic, initialAuthority.issueCode);
+            throw stateError(initialAuthority.issueCode);
+        }
+        const initialDiagnostic = createDiagnostic({
+            requestId: initialHead.state.requestId,
+            call: initialAuthority.call,
+            registeredRoleIds,
+        });
+        traceRoleExecutorResolved(initialDiagnostic);
+        return Object.freeze({
+            executor,
+            initialHead,
+            call: initialAuthority.call,
+        });
+    }
+    requireCurrentActivation(turnCount) {
+        const { input, registeredRoleIds } = this.params;
+        let before;
+        try {
+            before = input.ledger.current();
+        }
+        catch {
+            const diagnostic = createDiagnostic({
+                requestId: input.requestId,
+                call: this.expectedCall,
+                registeredRoleIds,
+            });
+            traceRoleExecutorStateRejected(diagnostic, "ledger_read_failed", turnCount);
+            throw stateError("ledger_read_failed");
+        }
+        const authority = resolveCurrentCall({
+            head: before,
+            requestId: input.requestId,
+            expectedCall: this.expectedCall,
+        });
+        const diagnostic = createDiagnostic({
+            requestId: input.requestId,
+            call: authority.ok ? authority.call : this.expectedCall,
+            registeredRoleIds,
+        });
+        if (!authority.ok) {
+            traceRoleExecutorStateRejected(diagnostic, authority.issueCode, turnCount);
+            throw stateError(authority.issueCode);
+        }
+        return Object.freeze({
+            before,
+            call: authority.call,
+            diagnostic,
+        });
+    }
+    async runActivation(executor, activation, turnCount) {
+        const { input, registeredRoleIds } = this.params;
+        const availableChildRoleIds = Object.freeze(registeredRoleIds.filter((roleId) => roleId !== activation.call.roleId));
+        traceRoleExecutorStarted(activation.diagnostic, {
+            availableChildRoleIds,
+            turnCount,
+        });
+        try {
+            const result = normalizeRoleExecutorActivationResult(await executor.execute({
+                context: input.context,
+                call: activation.call,
+                ledger: input.ledger,
+                availableChildRoleIds,
+                ...(this.continuationReference
+                    ? { continuation: this.continuationReference }
+                    : {}),
+            }), activation.before.policy.limits.maxResultChars, activation.before.policy.limits.maxObjectiveChars);
+            if (!result.ok) {
+                traceRoleExecutorResultRejected(activation.diagnostic, result.issueCode);
+                throw new Error("role_executor_result_invalid:" +
+                    activation.call.roleId +
+                    ":" +
+                    result.issueCode);
+            }
+            if (result.value.kind === "terminal") {
+                return this.completeTerminal(activation, result.value, turnCount);
+            }
+            if (result.value.kind === "invoke_role") {
+                await this.continueThroughChild(activation, result.value, turnCount);
+                return undefined;
+            }
+            this.continueThroughCapability(activation, result.value, turnCount);
+            return undefined;
+        }
+        catch (error) {
+            traceRoleExecutorFailed(activation.diagnostic, error);
+            throw error;
+        }
+    }
+    completeTerminal(activation, result, turnCount) {
+        const after = readLedgerOrReject({
+            ledger: this.params.input.ledger,
+            diagnostic: activation.diagnostic,
+            turnCount,
+        });
+        if (!isTerminalStateFresh(after, activation.before)) {
+            traceRoleExecutorResultRejected(activation.diagnostic, "terminal_state_changed");
+            throw new Error("role_executor_result_invalid:" +
+                activation.call.roleId +
+                ":terminal_state_changed");
+        }
+        traceRoleExecutorCompleted(activation.diagnostic, {
+            outcome: result.outcome,
+            summaryLength: result.summary.length,
+            hasValue: result.value !== undefined,
+            turnCount,
+        });
+        return result;
+    }
+    async continueThroughChild(activation, result, turnCount) {
+        const { input } = this.params;
+        const child = await this.params.invokeChild({
+            requestId: input.requestId,
+            context: input.context,
+            callerCall: activation.call,
+            ledger: input.ledger,
+            expectedHead: activation.before,
+            roleId: result.roleId,
+            objective: result.objective,
+            ...(result.workerCapabilityScope
+                ? { workerCapabilityScope: result.workerCapabilityScope }
+                : {}),
+            ...(result.workingDirectory !== undefined
+                ? { workingDirectory: result.workingDirectory }
+                : {}),
+            ...(result.plannerPlan ? { plannerPlan: result.plannerPlan } : {}),
+            turnCount,
+        });
+        const continuationReference = Object.freeze({
+            kind: "role_child",
+            commit: child.returnCommit,
+        });
+        this.expectedCall = requireResumedCallerCall(child.returnCommit, activation.call);
+        this.continuationReference = continuationReference;
+    }
+    continueThroughCapability(activation, result, turnCount) {
+        const after = readLedgerOrReject({
+            ledger: this.params.input.ledger,
+            diagnostic: activation.diagnostic,
+            turnCount,
+        });
+        const executionIds = result.continuation.kind === "capability_batch_execution"
+            ? result.continuation.executionIds
+            : [result.continuation.executionId];
+        const continuation = validateCapabilityContinuation({
+            before: activation.before,
+            after,
+            currentCall: activation.call,
+            executionIds,
+        });
+        if (!continuation.ok) {
+            traceRoleExecutorContinuationRejected(activation.diagnostic, {
+                issueCode: continuation.issueCode,
+                ...(result.continuation.kind === "capability_batch_execution"
+                    ? { executionIds }
+                    : { executionId: executionIds[0] }),
+                fromActivation: activation.call.activationCount,
+                turnCount,
+            });
+            throw continuationError(activation.call.roleId, continuation.issueCode);
+        }
+        traceRoleExecutorContinued(activation.diagnostic, {
+            ...(result.continuation.kind === "capability_batch_execution"
+                ? { executionIds }
+                : { executionId: executionIds[0] }),
+            fromActivation: activation.call.activationCount,
+            toActivation: continuation.call.activationCount,
+            turnCount,
+        });
+        this.expectedCall = continuation.call;
+        this.continuationReference = result.continuation;
+    }
+}
+function isTerminalStateFresh(after, before) {
+    return after === before;
+}

package/dist/src/runtime/orchestration/role-executors/activation/result-normalization.d.ts

@@ -0,0 +1,8 @@
+import type { RoleExecutorActivationResult } from "../contracts.js";
+export declare function normalizeRoleExecutorActivationResult<TValue>(input: RoleExecutorActivationResult<TValue>, maxSummaryLength: number, maxObjectiveLength: number): Readonly<{
+    ok: true;
+    value: RoleExecutorActivationResult<TValue>;
+}> | Readonly<{
+    ok: false;
+    issueCode: string;
+}>;

package/dist/src/runtime/orchestration/role-executors/activation/result-normalization.js

@@ -0,0 +1,117 @@
+import { isRoleCallWorkingDirectoryRoleId, normalizeRoleCallWorkingDirectory, parseRoleCallPlanBinding, parseRoleCallWorkerCapabilityScope, } from "../../role-calls/index.js";
+import { isRuntimeDelegateRoleId } from "../../roles.js";
+export function normalizeRoleExecutorActivationResult(input, maxSummaryLength, maxObjectiveLength) {
+    if (!isPlainRecord(input)) {
+        return { ok: false, issueCode: "result_not_object" };
+    }
+    if (input.kind === "terminal") {
+        if (!hasExactKeys(input, ["kind", "outcome", "summary"], ["value"]) ||
+            (input.outcome !== "completed" && input.outcome !== "failed")) {
+            return { ok: false, issueCode: "terminal_shape_invalid" };
+        }
+        if (typeof input.summary !== "string" ||
+            input.summary.trim().length === 0 ||
+            input.summary.length > maxSummaryLength) {
+            return { ok: false, issueCode: "summary_invalid" };
+        }
+        return {
+            ok: true,
+            value: Object.freeze({
+                kind: "terminal",
+                outcome: input.outcome,
+                summary: input.summary.trim(),
+                ...(input.value !== undefined ? { value: input.value } : {}),
+            }),
+        };
+    }
+    if (input.kind === "invoke_role") {
+        const plannerPlan = input.plannerPlan === undefined
+            ? undefined
+            : parseRoleCallPlanBinding(input.plannerPlan);
+        const workerCapabilityScope = input.workerCapabilityScope === undefined
+            ? undefined
+            : parseRoleCallWorkerCapabilityScope(input.workerCapabilityScope);
+        const workingDirectory = normalizeRoleCallWorkingDirectory(input.workingDirectory);
+        if (!hasExactKeys(input, ["kind", "roleId", "objective"], ["plannerPlan", "workerCapabilityScope", "workingDirectory"]) ||
+            !isRuntimeDelegateRoleId(input.roleId) ||
+            typeof input.objective !== "string" ||
+            input.objective.trim().length === 0 ||
+            input.objective.length > maxObjectiveLength ||
+            (input.plannerPlan !== undefined && !plannerPlan) ||
+            (input.workerCapabilityScope !== undefined && !workerCapabilityScope) ||
+            (workerCapabilityScope !== undefined && input.roleId !== "worker") ||
+            (input.workingDirectory !== undefined && !workingDirectory) ||
+            (workingDirectory !== undefined &&
+                !isRoleCallWorkingDirectoryRoleId(input.roleId))) {
+            return { ok: false, issueCode: "child_invocation_shape_invalid" };
+        }
+        return {
+            ok: true,
+            value: Object.freeze({
+                kind: "invoke_role",
+                roleId: input.roleId,
+                objective: input.objective.trim(),
+                ...(workerCapabilityScope ? { workerCapabilityScope } : {}),
+                ...(workingDirectory !== undefined ? { workingDirectory } : {}),
+                ...(plannerPlan ? { plannerPlan } : {}),
+            }),
+        };
+    }
+    if (input.kind !== "continue" ||
+        !hasExactKeys(input, ["kind", "continuation"]) ||
+        !isPlainRecord(input.continuation)) {
+        return { ok: false, issueCode: "continuation_shape_invalid" };
+    }
+    if (hasExactKeys(input.continuation, ["kind", "executionId"]) &&
+        input.continuation.kind === "capability_execution" &&
+        isCapabilityExecutionId(input.continuation.executionId)) {
+        return {
+            ok: true,
+            value: Object.freeze({
+                kind: "continue",
+                continuation: Object.freeze({
+                    kind: "capability_execution",
+                    executionId: input.continuation.executionId,
+                }),
+            }),
+        };
+    }
+    if (hasExactKeys(input.continuation, ["kind", "executionIds"]) &&
+        input.continuation.kind === "capability_batch_execution" &&
+        Array.isArray(input.continuation.executionIds) &&
+        input.continuation.executionIds.length >= 2 &&
+        input.continuation.executionIds.every(isCapabilityExecutionId) &&
+        new Set(input.continuation.executionIds).size ===
+            input.continuation.executionIds.length) {
+        return {
+            ok: true,
+            value: Object.freeze({
+                kind: "continue",
+                continuation: Object.freeze({
+                    kind: "capability_batch_execution",
+                    executionIds: Object.freeze([...input.continuation.executionIds]),
+                }),
+            }),
+        };
+    }
+    return { ok: false, issueCode: "continuation_shape_invalid" };
+}
+function hasExactKeys(input, required, optional = []) {
+    const keys = Object.keys(input);
+    return (required.every((key) => keys.includes(key)) &&
+        keys.every((key) => required.includes(key) || optional.includes(key)) &&
+        keys.length >= required.length &&
+        keys.length <= required.length + optional.length);
+}
+function isPlainRecord(input) {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(input);
+    return prototype === Object.prototype || prototype === null;
+}
+function isCapabilityExecutionId(input) {
+    return (typeof input === "string" &&
+        input.length <= 128 &&
+        /^capability-execution-[1-9][0-9]*$/u.test(input));
+}

package/dist/src/runtime/orchestration/role-executors/activation/state-validation.d.ts

@@ -0,0 +1,24 @@
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../role-calls/index.js";
+export declare function resolveCurrentCall(params: Readonly<{
+    head: RoleCallLedgerHead;
+    requestId: string;
+    expectedCall: RoleCallFrame;
+}>): Readonly<{
+    ok: true;
+    call: RoleCallFrame;
+}> | Readonly<{
+    ok: false;
+    issueCode: string;
+}>;
+export declare function validateCapabilityContinuation(params: Readonly<{
+    before: RoleCallLedgerHead;
+    after: RoleCallLedgerHead;
+    currentCall: RoleCallFrame;
+    executionIds: readonly string[];
+}>): Readonly<{
+    ok: true;
+    call: RoleCallFrame;
+}> | Readonly<{
+    ok: false;
+    issueCode: string;
+}>;

package/dist/src/runtime/orchestration/role-executors/activation/state-validation.js

@@ -0,0 +1,137 @@
+import { isRuntimeDelegateRoleId } from "../../roles.js";
+import { sameCallFrame, sameCallIdentity, } from "../shared/runtime-invariants.js";
+export function resolveCurrentCall(params) {
+    try {
+        if (params.head.state.requestId !== params.requestId) {
+            return { ok: false, issueCode: "request_id_mismatch" };
+        }
+        if (params.head.state.activeCallId !== params.expectedCall.callId) {
+            return { ok: false, issueCode: "call_not_current" };
+        }
+        const call = params.head.state.calls.find((candidate) => candidate.callId === params.expectedCall.callId);
+        if (!call)
+            return { ok: false, issueCode: "call_unavailable" };
+        if (!isExecutableCall(call)) {
+            return { ok: false, issueCode: "call_not_executable" };
+        }
+        if (!sameCallFrame(call, params.expectedCall)) {
+            return { ok: false, issueCode: "call_identity_mismatch" };
+        }
+        return { ok: true, call };
+    }
+    catch {
+        return { ok: false, issueCode: "ledger_head_invalid" };
+    }
+}
+export function validateCapabilityContinuation(params) {
+    try {
+        if (params.after === params.before) {
+            return { ok: false, issueCode: "ledger_not_advanced" };
+        }
+        if (params.after.revision !== params.before.revision + 2) {
+            return { ok: false, issueCode: "revision_advance_invalid" };
+        }
+        if (params.after.policy !== params.before.policy) {
+            return { ok: false, issueCode: "policy_changed" };
+        }
+        const beforeState = params.before.state;
+        const afterState = params.after.state;
+        if (afterState.requestId !== beforeState.requestId ||
+            afterState.phase !== beforeState.phase ||
+            afterState.phase !== "running" ||
+            afterState.rootCallId !== beforeState.rootCallId ||
+            afterState.rootResponse !== beforeState.rootResponse ||
+            afterState.callSequence !== beforeState.callSequence ||
+            afterState.resultSequence !== beforeState.resultSequence ||
+            afterState.capabilityExecutionSequence !==
+                beforeState.capabilityExecutionSequence + params.executionIds.length ||
+            afterState.activeCallId !== params.currentCall.callId ||
+            afterState.results !== beforeState.results) {
+            return { ok: false, issueCode: "ledger_progress_invalid" };
+        }
+        if (afterState.calls.length !== beforeState.calls.length) {
+            return { ok: false, issueCode: "call_set_changed" };
+        }
+        const nextCall = afterState.calls.find((candidate) => candidate.callId === params.currentCall.callId);
+        if (!nextCall)
+            return { ok: false, issueCode: "call_unavailable" };
+        if (nextCall.status !== "active" ||
+            nextCall.activationCount !== params.currentCall.activationCount + 1 ||
+            !sameCallIdentity(nextCall, params.currentCall)) {
+            return { ok: false, issueCode: "activation_advance_invalid" };
+        }
+        for (const beforeCall of beforeState.calls) {
+            if (beforeCall.callId === params.currentCall.callId)
+                continue;
+            if (afterState.calls.find((candidate) => candidate.callId === beforeCall.callId) !== beforeCall) {
+                return { ok: false, issueCode: "unrelated_call_changed" };
+            }
+        }
+        if (afterState.capabilityExecutions.length !==
+            beforeState.capabilityExecutions.length + params.executionIds.length ||
+            !beforeState.capabilityExecutions.every((execution, index) => afterState.capabilityExecutions[index] === execution)) {
+            return { ok: false, issueCode: "execution_set_changed" };
+        }
+        const beforeExecutionIds = new Set(beforeState.capabilityExecutions.map((execution) => execution.executionId));
+        if (params.executionIds.length < 1 ||
+            new Set(params.executionIds).size !== params.executionIds.length ||
+            params.executionIds.some((executionId) => beforeExecutionIds.has(executionId))) {
+            return { ok: false, issueCode: "execution_not_new" };
+        }
+        const appendedExecutions = afterState.capabilityExecutions.filter((execution) => !beforeExecutionIds.has(execution.executionId));
+        if (appendedExecutions.length !== params.executionIds.length) {
+            return { ok: false, issueCode: "execution_set_changed" };
+        }
+        for (let index = 0; index < params.executionIds.length; index += 1) {
+            const execution = appendedExecutions[index];
+            if (execution?.executionId !== params.executionIds[index]) {
+                return { ok: false, issueCode: "execution_unavailable" };
+            }
+            const executionIssue = validateSettledExecution({
+                execution,
+                call: params.currentCall,
+            });
+            if (executionIssue) {
+                return { ok: false, issueCode: executionIssue };
+            }
+            if (params.executionIds.length > 1 &&
+                execution.declaredEffect !== "observation") {
+                return { ok: false, issueCode: "execution_batch_effect_invalid" };
+            }
+        }
+        return { ok: true, call: nextCall };
+    }
+    catch {
+        return { ok: false, issueCode: "continuation_state_invalid" };
+    }
+}
+function validateSettledExecution(params) {
+    const execution = params.execution;
+    if (!execution)
+        return "execution_unavailable";
+    if (execution.callId !== params.call.callId) {
+        return "execution_call_mismatch";
+    }
+    if (execution.invocationAttempt !== params.call.activationCount) {
+        return "execution_activation_mismatch";
+    }
+    if (execution.status !== "settled" ||
+        execution.outcome === null ||
+        execution.observedEffect === null ||
+        execution.summary === null ||
+        execution.summary.length === 0) {
+        return "execution_not_settled";
+    }
+    return undefined;
+}
+function isExecutableCall(call) {
+    return (isRuntimeDelegateRoleId(call.roleId) &&
+        call.parentCallId !== null &&
+        call.depth >= 1 &&
+        call.objective !== null &&
+        call.objective.trim().length > 0 &&
+        call.status === "active" &&
+        Number.isInteger(call.activationCount) &&
+        call.activationCount >= 1 &&
+        call.resultRef === null);
+}

package/dist/src/runtime/orchestration/role-executors/child-invocation/diagnostic-fields.d.ts

@@ -0,0 +1,4 @@
+import type { RoleCallFrame, RoleCallPlanBinding } from "../../role-calls/index.js";
+export declare function workerCapabilityScopeDiagnosticFields(scope: RoleCallFrame["workerCapabilityScope"]): Record<string, unknown>;
+export declare function workingDirectoryDiagnosticFields(workingDirectory: string | undefined): Record<string, unknown>;
+export declare function planBindingDiagnosticFields(binding: RoleCallPlanBinding | undefined): Record<string, unknown>;

package/dist/src/runtime/orchestration/role-executors/child-invocation/diagnostic-fields.js

@@ -0,0 +1,39 @@
+export function workerCapabilityScopeDiagnosticFields(scope) {
+    return scope
+        ? {
+            workerCapabilityCatalogGroupIds: scope.catalogGroupIds,
+            workerCapabilityCatalogGroupCount: scope.catalogGroupIds.length,
+        }
+        : { workerCapabilityCatalogGroupCount: 0 };
+}
+export function workingDirectoryDiagnosticFields(workingDirectory) {
+    return {
+        workingDirectoryIncluded: workingDirectory !== undefined,
+        workingDirectoryLength: workingDirectory?.length ?? 0,
+    };
+}
+export function planBindingDiagnosticFields(binding) {
+    if (!binding)
+        return { planBindingMode: "none" };
+    if (binding.mode === "select") {
+        return {
+            planBindingMode: "select",
+            selectedPlanItemIds: binding.itemIds,
+            selectedPlanItemCount: binding.itemIds.length,
+        };
+    }
+    if (binding.mode === "extend") {
+        return {
+            planBindingMode: "extend",
+            plannedItemCount: binding.extension.items.length,
+            selectedPlanItemIndexes: binding.selectedItemIndexes,
+            selectedPlanItemCount: binding.selectedItemIndexes.length,
+        };
+    }
+    return {
+        planBindingMode: "declare",
+        plannedItemCount: binding.plan.items.length,
+        selectedPlanItemIndexes: binding.selectedItemIndexes,
+        selectedPlanItemCount: binding.selectedItemIndexes.length,
+    };
+}

package/dist/src/runtime/orchestration/role-executors/child-invocation/state-validation.d.ts

@@ -0,0 +1,41 @@
+import type { RoleCallChildReturnCommit, RoleCallCommitEffect, RoleCallFrame, RoleCallLedger, RoleCallLedgerCommit, RoleCallLedgerHead } from "../../role-calls/index.js";
+import type { RuntimeDelegateRoleId } from "../../roles.js";
+import type { RoleExecutorRegistry } from "../contracts.js";
+type RoleChildInvocationInput<TContext, TValue> = Parameters<RoleExecutorRegistry<TContext, TValue>["invokeChild"]>[0];
+export type ChildOpenedCommit = RoleCallLedgerCommit & Readonly<{
+    effect: Extract<RoleCallCommitEffect, {
+        type: "child_opened";
+    }>;
+}>;
+export type ChildReturnedCommit = RoleCallLedgerCommit & Readonly<{
+    effect: Extract<RoleCallCommitEffect, {
+        type: "child_returned";
+    }>;
+}>;
+export type DelegateRoleCallFrame = RoleCallFrame & Readonly<{
+    roleId: RuntimeDelegateRoleId;
+}>;
+export type OpenedChild = Readonly<{
+    commit: ChildOpenedCommit;
+    call: DelegateRoleCallFrame;
+}>;
+export declare function isValidOpenedChildProjection<TContext, TValue>(ledger: RoleCallLedger, opened: ChildOpenedCommit, callerCall: RoleCallFrame, input: RoleChildInvocationInput<TContext, TValue>, dependencyResultRefs: readonly string[], childCall: RoleCallFrame | undefined): childCall is DelegateRoleCallFrame;
+export declare function isValidChildReturnTransition(commit: ChildReturnedCommit, opened: ChildOpenedCommit): boolean;
+export declare function isValidResumeProjection(resume: Readonly<{
+    callerCallId: string;
+    invocationAttempt: number;
+}>, resumedCall: RoleCallFrame): boolean;
+export declare function projectPriorDirectSiblingResultRefs(head: RoleCallLedgerHead, callerCall: RoleCallFrame): readonly string[];
+export declare function resolveActiveCaller(params: Readonly<{
+    head: RoleCallLedgerHead;
+    requestId: string;
+    expectedCall: RoleCallFrame;
+}>): Readonly<{
+    ok: true;
+    call: RoleCallFrame;
+}> | Readonly<{
+    ok: false;
+    issueCode: string;
+}>;
+export declare function requireResumedCallerCall(commit: RoleCallChildReturnCommit, previousCall: RoleCallFrame): RoleCallFrame;
+export {};