Class RemoteStepJournal

new RemoteStepJournal(
    input: {
        allowedToolIds: readonly string[];
        db: ExecutionFenceDatabase;
        deploymentId: string;
        fence: ExecutionFenceStore;
        now?: () => number;
        runtime: Pick<
            RunnerRuntime,
            "authoritativeStatus"
            | "authoritativeStartState",
        >;
        tablePrefix: string;
        verifyCompletion: (
            input: {
                evidenceJson: string;
                invocation: RemoteStepInvocation;
                rawPermit: string;
                resultJson: string;
            },
        ) => Promise<void>;
        verifyWorkflowCompletion?: (
            input: {
                evidenceJson: string;
                invocation: WorkflowRemoteStepInvocation;
                rawPermit: string;
                resultJson: string;
            },
        ) => Promise<void>;
    },
): RemoteStepJournal

admitNotificationEffect(
    invocationId: string,
): Promise<RemoteStepNotificationOperation>

admitNotificationResume(invocationId: string): Promise<string>

claimResume(invocationId: string, leaseMs: number): Promise<string>

claimWorkflowResume(
    invocationId: string,
    leaseMs: number,
    expectedMutationEpoch?: number,
): Promise<string>

consumePermit(
    permit: RemoteStepPermit,
): Promise<
    { kind: "accepted"; rawPermit: string }
    | { kind: "already-consumed" },
>

get(invocationId: string): Promise<RemoteStepInvocation | undefined>

getWorkflow(
    invocationId: string,
): Promise<WorkflowRemoteStepInvocation | undefined>

initialize(): Promise<void>

issuePermit(invocationId: string, lifetimeMs: number): Promise<RemoteStepPermit>

nextNotificationRecoveryBatch(limit: number): Promise<string[]>

notificationStorage(operationReceiptLimit?: number): D1NotificationsStorage

prepareNotificationOperation(
    invocationId: string,
    operationId: string,
    input: Omit<NotificationOperationInput, "id">,
): Promise<RemoteStepNotificationOperation>

readDispatchRequestJson(invocationId: string): Promise<string>

readNotificationOperation(
    invocationId: string,
): Promise<RemoteStepNotificationOperation | undefined>

readRetainedResult(
    invocationId: string,
): Promise<RecordedRemoteStepResult | undefined>

readWorkflowDispatchRequestJson(invocationId: string): Promise<string>

reconcileResult(
    invocationId: string,
): Promise<
    | "retry"
    | "applied"
    | "terminal-not-success"
    | "deadline-expired"
    | "advanced-without-proof"
    | "pending-quiescence",
>

recordNotificationReceipt(
    invocationId: string,
    receipt: {
        notificationId: string;
        operationKey: string;
        requestDigest: string;
        threadId: string;
    },
): Promise<RemoteStepNotificationOperation>

recordResult(
    invocationId: string,
    rawPermit: string,
    resultJson: string,
    evidenceJson: string,
): Promise<
    | { kind: "recorded"; resultDigest: string; resultJson: string }
    | { kind: "replay"; resultDigest: string; resultJson: string },
>

recoverableResults(
    limit: number,
    afterInvocationId?: string,
): Promise<{ invocationIds: string[]; nextCursor?: string }>

register(
    address: RemoteStepAddress,
    hostDeadlineAt: number,
    originalPrincipal: ExecutionPrincipal,
): Promise<RemoteStepInvocation>

registerWorkflow(
    address: WorkflowRemoteStepAddress,
    hostDeadlineAt: number,
    originalPrincipal: ExecutionPrincipal,
): Promise<WorkflowRemoteStepInvocation>

settleAfterResume(
    invocationId: string,
    leaseOwner: string,
    witnessed?: RunSummary,
): Promise<
    | "retry"
    | "applied"
    | "terminal-not-success"
    | "deadline-expired"
    | "advanced-without-proof",
>

settleWorkflowAfterResume(
    invocationId: string,
    leaseOwner: string,
    witnessed: RunSummary,
): Promise<"applied" | "terminal-not-success" | "unresolved">