@maiaos/node 0.1.0-canary.44938d4.manual.1

package/dist/orchestration/storage.js

@@ -0,0 +1,1214 @@
+import { Buffer } from "node:buffer";
+import { createHash, randomUUID } from "node:crypto";
+import { inspectOrchestrationRunCreateAdmission, MAX_ORCHESTRATION_CHECK_RESULT_BYTES, MAX_ORCHESTRATION_DELIVERIES_PER_MAILBOX, MAX_ORCHESTRATION_DELIVERY_ATTEMPTS, MAX_ORCHESTRATION_DISPATCH_SHOW_RESULT_BYTES, MAX_ORCHESTRATION_LIST_RESULT_BYTES, MAX_ORCHESTRATION_MAILBOX_CONTENT_BYTES, MAX_ORCHESTRATION_RUN_MESSAGE_CONTENT_BYTES, MAX_ORCHESTRATION_TASK_LIST_RESULT_BYTES, MAX_ORCHESTRATION_TASK_SHOW_RESULT_BYTES, ORCHESTRATION_MESSAGE_SCHEMA_VERSION, ORCHESTRATION_SCHEMA_VERSION, orchestrationAggregateSchema, orchestrationDeliverySchema, orchestrationDispatchShowParametersSchema, orchestrationDispatchShowResultSchema, orchestrationInboxAckResultSchema, orchestrationInboxCheckResultSchema, orchestrationMailboxSchema, orchestrationRunCreateParametersSchema, orchestrationRunCreateResultSchema, orchestrationRunListParametersSchema, orchestrationRunListResultSchema, orchestrationRunShowResultSchema, orchestrationTaskListParametersSchema, orchestrationTaskListResultSchema, orchestrationTaskShowParametersSchema, orchestrationTaskShowResultSchema, } from "@maiaos/protocol";
+import { Schema } from "effect";
+import { commandReceiptFromPersisted } from "../command-receipt/storage/codec.js";
+import { makeNodeRuntimeError, NodeRuntimeError } from "../runtime/errors.js";
+import { commitCommandWithMutation, commitIdempotentCommandReceipt, findPersistedCommand, } from "../storage/journal.js";
+import { advanceSignedSqliteInteger } from "../storage/sqlite-integer.js";
+export const ORCHESTRATION_RUN_AGGREGATE_TYPE = "orchestration-run";
+export const ORCHESTRATION_MAILBOX_AGGREGATE_TYPE = "orchestration-mailbox";
+const LOCAL_USER_ACTOR_ID = "actor_local_user";
+export const id = (prefix) => `${prefix}_${randomUUID().replaceAll("-", "")}`;
+export const requireLocalCoordinatorActor = (actorId) => {
+    if (actorId !== LOCAL_USER_ACTOR_ID) {
+        throw makeNodeRuntimeError("authentication_failed", "Only the authenticated local Run coordinator may mutate orchestration state.");
+    }
+};
+export const statementWithBigInts = (database, sql) => {
+    const statement = database.prepare(sql);
+    statement.setReadBigInts(true);
+    return statement;
+};
+const runRowSchema = Schema.Struct({
+    coordinatorActorId: Schema.String,
+    coordinatorEpoch: Schema.BigInt,
+    createdAt: Schema.String,
+    dispatchTaskId: Schema.String,
+    id: Schema.String,
+    messageContentBytes: Schema.BigInt,
+    revision: Schema.BigInt,
+    rootTaskId: Schema.String,
+    state: Schema.String,
+    terminalId: Schema.String,
+    updatedAt: Schema.String,
+    workspaceId: Schema.String,
+});
+const decodeRunRow = Schema.decodeUnknownSync(runRowSchema);
+const taskRowSchema = Schema.Struct({
+    clientKey: Schema.String,
+    createdAt: Schema.String,
+    id: Schema.String,
+    objective: Schema.String,
+    revision: Schema.BigInt,
+    runId: Schema.String,
+    state: Schema.String,
+    updatedAt: Schema.String,
+    workspaceId: Schema.String,
+});
+const decodeTaskRow = Schema.decodeUnknownSync(taskRowSchema);
+const taskDependencyRowSchema = Schema.Struct({
+    dependencyTaskId: Schema.String,
+    taskId: Schema.String,
+});
+const decodeTaskDependencyRow = Schema.decodeUnknownSync(taskDependencyRowSchema);
+const attemptRowSchema = Schema.Struct({
+    createdAt: Schema.String,
+    id: Schema.String,
+    ordinal: Schema.BigInt,
+    revision: Schema.BigInt,
+    runId: Schema.String,
+    state: Schema.String,
+    taskId: Schema.String,
+    updatedAt: Schema.String,
+});
+const decodeAttemptRow = Schema.decodeUnknownSync(attemptRowSchema);
+const dispatchRowSchema = Schema.Struct({
+    attemptId: Schema.String,
+    createdAt: Schema.String,
+    failureCode: Schema.NullOr(Schema.String),
+    failurePlatform: Schema.NullOr(Schema.String),
+    id: Schema.String,
+    revision: Schema.BigInt,
+    runId: Schema.String,
+    state: Schema.String,
+    taskId: Schema.String,
+    terminalId: Schema.String,
+    updatedAt: Schema.String,
+});
+const decodeDispatchRow = Schema.decodeUnknownSync(dispatchRowSchema);
+const mailboxRowSchema = Schema.Struct({
+    contentBytes: Schema.BigInt,
+    createdAt: Schema.String,
+    deliveryCount: Schema.BigInt,
+    headSequence: Schema.BigInt,
+    id: Schema.String,
+    ownerId: Schema.String,
+    ownerKind: Schema.String,
+    revision: Schema.BigInt,
+    runId: Schema.String,
+    updatedAt: Schema.String,
+});
+const decodeMailboxRow = Schema.decodeUnknownSync(mailboxRowSchema);
+const questionRowSchema = Schema.Struct({
+    answer: Schema.NullOr(Schema.String),
+    askMessageId: Schema.String,
+    attemptId: Schema.String,
+    body: Schema.String,
+    createdAt: Schema.String,
+    dispatchId: Schema.String,
+    id: Schema.String,
+    replyMessageId: Schema.NullOr(Schema.String),
+    revision: Schema.BigInt,
+    runId: Schema.String,
+    state: Schema.String,
+    subject: Schema.String,
+    taskId: Schema.String,
+    updatedAt: Schema.String,
+});
+export const decodeQuestionRow = Schema.decodeUnknownSync(questionRowSchema);
+const deliveryRowSchema = Schema.Struct({
+    acknowledgedAt: Schema.NullOr(Schema.String),
+    acknowledgingActorId: Schema.NullOr(Schema.String),
+    attemptCount: Schema.BigInt,
+    body: Schema.String,
+    createdAt: Schema.String,
+    digest: Schema.String,
+    firstDeliveredAt: Schema.NullOr(Schema.String),
+    id: Schema.String,
+    lastDeliveredAt: Schema.NullOr(Schema.String),
+    mailboxId: Schema.String,
+    messageCreatedAt: Schema.String,
+    messageId: Schema.String,
+    messageType: Schema.String,
+    questionId: Schema.NullOr(Schema.String),
+    recipientId: Schema.String,
+    recipientKind: Schema.String,
+    runId: Schema.String,
+    senderActorId: Schema.String,
+    senderKind: Schema.String,
+    senderRunId: Schema.String,
+    sequence: Schema.BigInt,
+    state: Schema.String,
+    subject: Schema.String,
+});
+const decodeDeliveryRow = Schema.decodeUnknownSync(deliveryRowSchema);
+const terminalAuthorityRowSchema = Schema.Struct({
+    code: Schema.String,
+    platform: Schema.String,
+    revision: Schema.BigInt,
+    state: Schema.String,
+    workspaceId: Schema.String,
+    workspaceRevision: Schema.BigInt,
+});
+const decodeTerminalAuthorityRow = Schema.decodeUnknownSync(terminalAuthorityRowSchema);
+export const readRunRow = (database, runId) => {
+    const row = statementWithBigInts(database, `SELECT run_id AS id, workspace_id AS workspaceId,
+      terminal_id AS terminalId, root_task_id AS rootTaskId,
+      dispatch_task_id AS dispatchTaskId,
+      coordinator_actor_id AS coordinatorActorId,
+      coordinator_epoch AS coordinatorEpoch, state, revision,
+      message_content_bytes AS messageContentBytes,
+      created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_runs WHERE run_id = ?`).get(runId);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("resource_not_found", "The Run was not found.");
+    }
+    return decodeRunRow(row);
+};
+export const readTaskRows = (database, runId) => statementWithBigInts(database, `SELECT task_id AS id, run_id AS runId, client_key AS clientKey,
+      workspace_id AS workspaceId, objective, state, revision,
+      created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_tasks WHERE run_id = ? ORDER BY sequence`)
+    .all(runId)
+    .map((row) => decodeTaskRow(row));
+export const readAttemptRow = (database, runId) => {
+    const row = statementWithBigInts(database, `SELECT attempt_id AS id, run_id AS runId, task_id AS taskId,
+      ordinal, state, revision, created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_attempts WHERE run_id = ?`).get(runId);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("storage_corrupt", "The Run Attempt is missing.");
+    }
+    return decodeAttemptRow(row);
+};
+export const readDispatchRow = (database, runId) => {
+    const row = statementWithBigInts(database, `SELECT dispatch_id AS id, run_id AS runId, task_id AS taskId,
+      attempt_id AS attemptId, terminal_id AS terminalId, state,
+      failure_code AS failureCode, failure_platform AS failurePlatform,
+      revision, created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_dispatches WHERE run_id = ?`).get(runId);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("storage_corrupt", "The Run Dispatch is missing.");
+    }
+    return decodeDispatchRow(row);
+};
+const readMailboxRows = (database, runId) => statementWithBigInts(database, `SELECT mailbox_id AS id, run_id AS runId, owner_kind AS ownerKind,
+      owner_id AS ownerId, head_sequence AS headSequence,
+      delivery_count AS deliveryCount, content_bytes AS contentBytes,
+      revision, created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_mailboxes WHERE run_id = ? ORDER BY sequence`)
+    .all(runId)
+    .map((row) => decodeMailboxRow(row));
+const readQuestionRow = (database, runId) => {
+    const row = statementWithBigInts(database, `SELECT question_id AS id, run_id AS runId, task_id AS taskId,
+      attempt_id AS attemptId, dispatch_id AS dispatchId,
+      ask_message_id AS askMessageId, reply_message_id AS replyMessageId,
+      subject, body, answer, state, revision,
+      created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_questions WHERE run_id = ?
+     ORDER BY sequence DESC LIMIT 1`).get(runId);
+    return row === undefined ? undefined : decodeQuestionRow(row);
+};
+const mailboxFromRow = (row) => orchestrationMailboxSchema.parse({
+    contentBytes: row.contentBytes.toString(),
+    createdAt: row.createdAt,
+    deliveryCount: row.deliveryCount.toString(),
+    headSequence: row.headSequence.toString(),
+    id: row.id,
+    owner: { id: row.ownerId, kind: row.ownerKind },
+    revision: row.revision.toString(),
+    runId: row.runId,
+    schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+    updatedAt: row.updatedAt,
+});
+const readDependencyTaskIdsByTask = (database, runId) => {
+    const rows = database
+        .prepare(`SELECT d.task_id AS taskId, d.dependency_task_id AS dependencyTaskId
+       FROM orchestration_task_dependencies d
+       JOIN orchestration_tasks t
+         ON t.run_id = d.run_id AND t.task_id = d.task_id
+       WHERE d.run_id = ?
+       ORDER BY t.sequence, d.position`)
+        .all(runId)
+        .map((row) => decodeTaskDependencyRow(row));
+    return rows.reduce((grouped, row) => {
+        const dependencyTaskIds = grouped.get(row.taskId) ?? [];
+        dependencyTaskIds.push(row.dependencyTaskId);
+        grouped.set(row.taskId, dependencyTaskIds);
+        return grouped;
+    }, new Map());
+};
+const attemptFromRow = (attempt) => ({
+    createdAt: attempt.createdAt,
+    id: attempt.id,
+    ordinal: Number(attempt.ordinal),
+    revision: attempt.revision.toString(),
+    runId: attempt.runId,
+    schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+    state: attempt.state,
+    taskId: attempt.taskId,
+    updatedAt: attempt.updatedAt,
+});
+const dispatchFromRow = (dispatch) => ({
+    attemptId: dispatch.attemptId,
+    createdAt: dispatch.createdAt,
+    ...(dispatch.failureCode === null || dispatch.failurePlatform === null
+        ? {}
+        : {
+            failure: {
+                code: dispatch.failureCode,
+                platform: dispatch.failurePlatform,
+            },
+        }),
+    id: dispatch.id,
+    revision: dispatch.revision.toString(),
+    runId: dispatch.runId,
+    schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+    state: dispatch.state,
+    taskId: dispatch.taskId,
+    terminalId: dispatch.terminalId,
+    updatedAt: dispatch.updatedAt,
+});
+const questionFromRow = (question) => ({
+    ...(question.answer === null ? {} : { answer: question.answer }),
+    askMessageId: question.askMessageId,
+    attemptId: question.attemptId,
+    body: question.body,
+    createdAt: question.createdAt,
+    dispatchId: question.dispatchId,
+    id: question.id,
+    ...(question.replyMessageId === null
+        ? {}
+        : { replyMessageId: question.replyMessageId }),
+    revision: question.revision.toString(),
+    runId: question.runId,
+    schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+    state: question.state,
+    subject: question.subject,
+    taskId: question.taskId,
+    updatedAt: question.updatedAt,
+});
+const runFromRow = (run) => ({
+    coordinator: {
+        actorId: run.coordinatorActorId,
+        epoch: Number(run.coordinatorEpoch),
+    },
+    createdAt: run.createdAt,
+    dispatchTaskId: run.dispatchTaskId,
+    id: run.id,
+    revision: run.revision.toString(),
+    rootTaskId: run.rootTaskId,
+    schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+    state: run.state,
+    terminalId: run.terminalId,
+    updatedAt: run.updatedAt,
+    workspaceId: run.workspaceId,
+});
+const taskFromRow = (task, dependencyTaskIdsByTask) => ({
+    clientKey: task.clientKey,
+    createdAt: task.createdAt,
+    dependencyTaskIds: dependencyTaskIdsByTask.get(task.id) ?? [],
+    id: task.id,
+    objective: task.objective,
+    revision: task.revision.toString(),
+    runId: task.runId,
+    schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+    state: task.state,
+    updatedAt: task.updatedAt,
+    workspaceId: task.workspaceId,
+});
+const readOrchestrationAggregateUnchecked = (database, runId) => {
+    const question = readQuestionRow(database, runId);
+    const dependencies = readDependencyTaskIdsByTask(database, runId);
+    return orchestrationAggregateSchema.parse({
+        attempt: attemptFromRow(readAttemptRow(database, runId)),
+        dispatch: dispatchFromRow(readDispatchRow(database, runId)),
+        mailboxes: readMailboxRows(database, runId).map(mailboxFromRow),
+        ...(question === undefined ? {} : { question: questionFromRow(question) }),
+        run: runFromRow(readRunRow(database, runId)),
+        tasks: readTaskRows(database, runId).map((task) => taskFromRow(task, dependencies)),
+    });
+};
+export const readOrchestrationAggregate = (database, runId) => {
+    try {
+        return readOrchestrationAggregateUnchecked(database, runId);
+    }
+    catch (error) {
+        if (error instanceof NodeRuntimeError)
+            throw error;
+        throw makeNodeRuntimeError("storage_corrupt", "The persisted orchestration Run is invalid.");
+    }
+};
+const deliverySelect = `SELECT d.delivery_id AS id, d.mailbox_id AS mailboxId,
+  d.mailbox_sequence AS sequence, d.state, d.attempt_count AS attemptCount,
+  d.first_delivered_at AS firstDeliveredAt,
+  d.last_delivered_at AS lastDeliveredAt,
+  d.acknowledging_actor_id AS acknowledgingActorId,
+  d.acknowledged_at AS acknowledgedAt, d.created_at AS createdAt,
+  m.message_id AS messageId, m.run_id AS runId,
+  m.sender_kind AS senderKind, m.sender_run_id AS senderRunId,
+  m.sender_actor_id AS senderActorId,
+  m.recipient_kind AS recipientKind, m.recipient_id AS recipientId,
+  m.message_type AS messageType, m.subject, m.body,
+  m.question_id AS questionId, m.content_digest AS digest,
+  m.created_at AS messageCreatedAt
+  FROM orchestration_deliveries d
+  JOIN orchestration_messages m ON m.message_id = d.message_id`;
+const deliveryMessageFromRow = (row) => ({
+    body: row.body,
+    createdAt: row.messageCreatedAt,
+    digest: row.digest,
+    id: row.messageId,
+    ...(row.questionId === null ? {} : { questionId: row.questionId }),
+    recipient: { id: row.recipientId, kind: row.recipientKind },
+    runId: row.runId,
+    schemaVersion: ORCHESTRATION_MESSAGE_SCHEMA_VERSION,
+    sender: {
+        actorId: row.senderActorId,
+        kind: row.senderKind,
+        runId: row.senderRunId,
+    },
+    subject: row.subject,
+    type: row.messageType,
+});
+const deliveryFromRow = (row) => orchestrationDeliverySchema.parse({
+    ...(row.acknowledgedAt === null
+        ? {}
+        : { acknowledgedAt: row.acknowledgedAt }),
+    ...(row.acknowledgingActorId === null
+        ? {}
+        : { acknowledgingActorId: row.acknowledgingActorId }),
+    attemptCount: Number(row.attemptCount),
+    createdAt: row.createdAt,
+    ...(row.firstDeliveredAt === null
+        ? {}
+        : { firstDeliveredAt: row.firstDeliveredAt }),
+    id: row.id,
+    ...(row.lastDeliveredAt === null
+        ? {}
+        : { lastDeliveredAt: row.lastDeliveredAt }),
+    mailboxId: row.mailboxId,
+    message: deliveryMessageFromRow(row),
+    sequence: row.sequence.toString(),
+    state: row.state,
+});
+export const readOrchestrationDelivery = (database, deliveryId) => {
+    try {
+        const row = statementWithBigInts(database, `${deliverySelect} WHERE d.delivery_id = ?`).get(deliveryId);
+        if (row === undefined) {
+            throw makeNodeRuntimeError("resource_not_found", "The Delivery was not found.");
+        }
+        return deliveryFromRow(decodeDeliveryRow(row));
+    }
+    catch (error) {
+        if (error instanceof NodeRuntimeError)
+            throw error;
+        throw makeNodeRuntimeError("storage_corrupt", "The persisted orchestration Delivery is invalid.");
+    }
+};
+const readMailboxForOwner = (database, runId, owner) => {
+    const row = statementWithBigInts(database, `SELECT mailbox_id AS id, run_id AS runId, owner_kind AS ownerKind,
+      owner_id AS ownerId, head_sequence AS headSequence,
+      delivery_count AS deliveryCount, content_bytes AS contentBytes,
+      revision, created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_mailboxes
+     WHERE run_id = ? AND owner_kind = ? AND owner_id = ?`).get(runId, owner.kind, owner.id);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("resource_not_found", "The scoped orchestration Mailbox was not found.");
+    }
+    return decodeMailboxRow(row);
+};
+export const requireCoordinator = (database, runId, coordinatorEpoch) => {
+    const run = readRunRow(database, runId);
+    if (run.coordinatorActorId !== LOCAL_USER_ACTOR_ID ||
+        run.coordinatorEpoch !== BigInt(coordinatorEpoch)) {
+        throw makeNodeRuntimeError("storage_conflict", "The Run coordinator epoch is no longer authoritative.", true);
+    }
+    return run;
+};
+export const requireDispatchScope = (database, scope) => {
+    const dispatch = readDispatchRow(database, scope.run.id);
+    if (dispatch.id !== scope.dispatchId ||
+        scope.run.revision !== BigInt(scope.expectedRunRevision) ||
+        dispatch.revision !== BigInt(scope.expectedDispatchRevision)) {
+        throw makeNodeRuntimeError("storage_conflict", "The Run or Dispatch revision changed before the mutation.", true);
+    }
+    return dispatch;
+};
+const updateAggregateRevision = (database, update) => {
+    database
+        .prepare(`INSERT INTO aggregate_revisions(aggregate_type, aggregate_id, revision)
+       VALUES (?, ?, ?)
+       ON CONFLICT(aggregate_type, aggregate_id)
+       DO UPDATE SET revision = excluded.revision`)
+        .run(update.aggregateType, update.aggregateId, update.revision);
+};
+export const requireOneChange = (result, message) => {
+    if (result.changes !== 1 && result.changes !== 1n) {
+        throw makeNodeRuntimeError("storage_conflict", message, true);
+    }
+};
+const requirePublicationCapacity = (mailbox, run, contentBytes) => {
+    if (mailbox.deliveryCount >= BigInt(MAX_ORCHESTRATION_DELIVERIES_PER_MAILBOX) ||
+        mailbox.contentBytes + BigInt(contentBytes) >
+            BigInt(MAX_ORCHESTRATION_MAILBOX_CONTENT_BYTES) ||
+        run.messageContentBytes + BigInt(contentBytes) >
+            BigInt(MAX_ORCHESTRATION_RUN_MESSAGE_CONTENT_BYTES)) {
+        throw makeNodeRuntimeError("mailbox_saturated", "The orchestration Mailbox durable quota is saturated.", true);
+    }
+};
+const publicationDigest = (input) => createHash("sha256")
+    .update(JSON.stringify([
+    ORCHESTRATION_MESSAGE_SCHEMA_VERSION,
+    input.runId,
+    input.owner.kind,
+    input.owner.id,
+    input.type,
+    input.subject,
+    input.body,
+    input.questionId ?? "",
+]))
+    .digest("hex");
+export const prepareOrchestrationPublication = (database, input, recordedAt) => {
+    const mailbox = readMailboxForOwner(database, input.runId, input.owner);
+    const run = readRunRow(database, input.runId);
+    const contentBytes = Buffer.byteLength(input.subject, "utf8") +
+        Buffer.byteLength(input.body, "utf8");
+    requirePublicationCapacity(mailbox, run, contentBytes);
+    return {
+        contentBytes,
+        deliveryId: input.deliveryId ?? id("delivery"),
+        digest: publicationDigest(input),
+        input,
+        mailbox,
+        messageId: input.messageId ?? id("message"),
+        nextMailboxRevision: advanceSignedSqliteInteger(mailbox.revision),
+        nextSequence: advanceSignedSqliteInteger(mailbox.headSequence),
+        recordedAt,
+        run,
+    };
+};
+const insertPublishedMessageSql = `INSERT INTO orchestration_messages(
+  message_id, run_id, sender_kind, sender_run_id, sender_actor_id,
+  recipient_kind, recipient_id, recipient_mailbox_id, message_type,
+  subject, body, question_id, content_bytes, content_digest, created_at
+) VALUES (?, ?, 'run-coordinator', ?, 'actor_local_user', ?, ?, ?, ?, ?, ?,
+  CASE WHEN ? = '' THEN NULL ELSE ? END, ?, ?, ?)`;
+const insertPublishedMessage = (database, publication) => {
+    const questionId = publication.input.questionId ?? "";
+    database
+        .prepare(insertPublishedMessageSql)
+        .run(publication.messageId, publication.input.runId, publication.input.runId, publication.input.owner.kind, publication.input.owner.id, publication.mailbox.id, publication.input.type, publication.input.subject, publication.input.body, questionId, questionId, publication.contentBytes, publication.digest, publication.recordedAt);
+};
+const insertPublishedDelivery = (database, publication) => {
+    database
+        .prepare(`INSERT INTO orchestration_deliveries(
+        delivery_id, mailbox_id, message_id, mailbox_sequence, state,
+        attempt_count, created_at
+      ) VALUES (?, ?, ?, ?, 'pending', 0, ?)`)
+        .run(publication.deliveryId, publication.mailbox.id, publication.messageId, publication.nextSequence, publication.recordedAt);
+};
+const advancePublishedMailbox = (database, publication) => {
+    requireOneChange(database
+        .prepare(`UPDATE orchestration_mailboxes SET head_sequence = ?,
+          delivery_count = delivery_count + 1,
+          content_bytes = content_bytes + ?, revision = ?, updated_at = ?
+         WHERE mailbox_id = ? AND revision = ?`)
+        .run(publication.nextSequence, publication.contentBytes, publication.nextMailboxRevision, publication.recordedAt, publication.mailbox.id, publication.mailbox.revision), "The Mailbox changed before publication.");
+    updateAggregateRevision(database, {
+        aggregateId: publication.mailbox.id,
+        aggregateType: ORCHESTRATION_MAILBOX_AGGREGATE_TYPE,
+        revision: publication.nextMailboxRevision,
+    });
+};
+const chargePublishedRun = (database, publication) => {
+    requireOneChange(database
+        .prepare(`UPDATE orchestration_runs
+         SET message_content_bytes = message_content_bytes + ?
+         WHERE run_id = ? AND message_content_bytes = ?`)
+        .run(publication.contentBytes, publication.run.id, publication.run.messageContentBytes), "The Run content quota changed before publication.");
+};
+export const persistOrchestrationPublication = (database, publication) => {
+    insertPublishedMessage(database, publication);
+    insertPublishedDelivery(database, publication);
+    advancePublishedMailbox(database, publication);
+    chargePublishedRun(database, publication);
+    return publication.deliveryId;
+};
+export const publishMessage = (database, input, recordedAt) => {
+    const publication = prepareOrchestrationPublication(database, input, recordedAt);
+    return persistOrchestrationPublication(database, publication);
+};
+const readTerminalAuthority = (database, workspaceId, terminalId) => {
+    const row = statementWithBigInts(database, `SELECT t.workspace_id AS workspaceId,
+      t.workspace_revision AS workspaceRevision, t.platform,
+      t.unavailability_code AS code, t.state, t.revision
+     FROM terminals t JOIN workspaces w ON w.workspace_id = t.workspace_id
+     WHERE t.terminal_id = ? AND t.workspace_id = ?
+       AND w.state = 'ready' AND w.revision = t.workspace_revision
+       AND NOT EXISTS (
+         SELECT 1 FROM terminal_live_generations live
+         WHERE live.terminal_id = t.terminal_id
+       )`).get(terminalId, workspaceId);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("storage_conflict", "The exact unavailable Terminal and Workspace identity is not authoritative.", true);
+    }
+    return decodeTerminalAuthorityRow(row);
+};
+export const requireTerminalAuthority = (database, workspaceId, terminalId) => {
+    const terminal = readTerminalAuthority(database, workspaceId, terminalId);
+    if (terminal.state !== "unavailable" || terminal.revision !== 1n) {
+        throw makeNodeRuntimeError("storage_conflict", "The Dispatch Terminal is not the unavailable candidate.", true);
+    }
+    return terminal;
+};
+export const readCommandPointer = (result) => {
+    const value = JSON.parse(result.resultJson);
+    if (typeof value !== "object" ||
+        value === null ||
+        !("runId" in value) ||
+        typeof value.runId !== "string" ||
+        ("deliveryId" in value && typeof value.deliveryId !== "string")) {
+        throw makeNodeRuntimeError("storage_corrupt", "The persisted orchestration command pointer is invalid.");
+    }
+    const pointer = value;
+    return {
+        ...(pointer.deliveryId === undefined
+            ? {}
+            : { deliveryId: pointer.deliveryId }),
+        runId: pointer.runId,
+    };
+};
+export const commandBase = (input) => ({
+    actorId: input.actorId,
+    aggregateId: input.aggregateId,
+    aggregateType: input.aggregateType,
+    commandId: input.commandId,
+    eventPayloadJson: JSON.stringify(input.eventPayload),
+    eventType: input.eventType,
+    expectedRevision: input.expectedRevision,
+    method: input.method,
+    requestDigest: input.requestDigest,
+    resultJson: JSON.stringify(input.pointer),
+    targetId: input.aggregateId,
+    targetType: input.aggregateType,
+});
+const runCreateResultFromCommand = (database, commandId, result) => {
+    const pointer = readCommandPointer(result);
+    if (pointer.deliveryId === undefined) {
+        throw makeNodeRuntimeError("storage_corrupt", "The Run creation Delivery pointer is missing.");
+    }
+    return orchestrationRunCreateResultSchema.parse({
+        aggregate: readOrchestrationAggregate(database, pointer.runId),
+        delivery: result.duplicate ? "duplicate" : "new",
+        initialDelivery: readOrchestrationDelivery(database, pointer.deliveryId),
+        method: "run.create",
+        receipt: commandReceiptFromPersisted(commandId, result),
+    });
+};
+const requireTaskIdentity = (input, clientKey) => {
+    const taskId = input.taskIds.get(clientKey);
+    if (taskId === undefined) {
+        throw makeNodeRuntimeError("storage_corrupt", "The admitted Task identity is missing.");
+    }
+    return taskId;
+};
+const insertRunRecord = (input, rootTaskId, dispatchTaskId) => {
+    input.database
+        .prepare(`INSERT INTO orchestration_runs(
+        run_id, workspace_id, terminal_id, root_task_id, dispatch_task_id,
+        coordinator_actor_id, coordinator_epoch, state, revision,
+        message_content_bytes, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, 'actor_local_user', 1, 'active', 1, 0, ?, ?)`)
+        .run(input.runId, input.parameters.workspaceId, input.parameters.terminalId, rootTaskId, dispatchTaskId, input.recordedAt, input.recordedAt);
+};
+const insertTaskRecords = (input) => {
+    input.parameters.graph.tasks.forEach((task) => {
+        input.database
+            .prepare(`INSERT INTO orchestration_tasks(
+          task_id, run_id, client_key, workspace_id, objective,
+          state, revision, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`)
+            .run(requireTaskIdentity(input, task.clientKey), input.runId, task.clientKey, input.parameters.workspaceId, task.objective, task.clientKey === input.parameters.graph.dispatchTaskKey
+            ? "active"
+            : "pending", input.recordedAt, input.recordedAt);
+    });
+};
+const insertTaskDependencyRecords = (input) => {
+    input.parameters.graph.tasks.forEach((task) => {
+        task.dependsOn.forEach((dependencyKey, position) => {
+            input.database
+                .prepare(`INSERT INTO orchestration_task_dependencies(
+            run_id, task_id, dependency_task_id, position
+          ) VALUES (?, ?, ?, ?)`)
+                .run(input.runId, requireTaskIdentity(input, task.clientKey), requireTaskIdentity(input, dependencyKey), position);
+        });
+    });
+};
+const insertAttemptRecord = (input, dispatchTaskId) => {
+    input.database
+        .prepare(`INSERT INTO orchestration_attempts(
+        attempt_id, run_id, task_id, ordinal, state, revision,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, 1, 'active', 1, ?, ?)`)
+        .run(input.attemptId, input.runId, dispatchTaskId, input.recordedAt, input.recordedAt);
+};
+const insertDispatchRecord = (input, dispatchTaskId) => {
+    input.database
+        .prepare(`INSERT INTO orchestration_dispatches(
+        dispatch_id, run_id, task_id, attempt_id, terminal_id,
+        state, revision, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, 'active', 1, ?, ?)`)
+        .run(input.dispatchId, input.runId, dispatchTaskId, input.attemptId, input.parameters.terminalId, input.recordedAt, input.recordedAt);
+};
+const insertMailboxRecord = (input) => {
+    const isRun = input.ownerKind === "run";
+    input.database
+        .prepare(`INSERT INTO orchestration_mailboxes(
+        mailbox_id, run_id, owner_kind, owner_id, run_owner_id,
+        dispatch_owner_id, created_at, updated_at
+      ) VALUES (?, ?, ?, ?,
+        CASE WHEN ? = 1 THEN ? ELSE NULL END,
+        CASE WHEN ? = 0 THEN ? ELSE NULL END, ?, ?)`)
+        .run(input.id, input.runId, input.ownerKind, input.ownerId, Number(isRun), input.ownerId, Number(isRun), input.ownerId, input.recordedAt, input.recordedAt);
+    updateAggregateRevision(input.database, {
+        aggregateId: input.id,
+        aggregateType: ORCHESTRATION_MAILBOX_AGGREGATE_TYPE,
+        revision: 1n,
+    });
+};
+const insertMailboxRecords = (input) => {
+    insertMailboxRecord({
+        database: input.database,
+        id: id("mailbox"),
+        ownerId: input.runId,
+        ownerKind: "run",
+        recordedAt: input.recordedAt,
+        runId: input.runId,
+    });
+    insertMailboxRecord({
+        database: input.database,
+        id: id("mailbox"),
+        ownerId: input.dispatchId,
+        ownerKind: "dispatch",
+        recordedAt: input.recordedAt,
+        runId: input.runId,
+    });
+};
+const insertRunRecords = (input) => {
+    requireTerminalAuthority(input.database, input.parameters.workspaceId, input.parameters.terminalId);
+    const rootTaskId = requireTaskIdentity(input, input.parameters.graph.rootTaskKey);
+    const dispatchTaskId = requireTaskIdentity(input, input.parameters.graph.dispatchTaskKey);
+    insertRunRecord(input, rootTaskId, dispatchTaskId);
+    insertTaskRecords(input);
+    insertTaskDependencyRecords(input);
+    insertAttemptRecord(input, dispatchTaskId);
+    insertDispatchRecord(input, dispatchTaskId);
+    insertMailboxRecords(input);
+};
+const makeRunCreation = (parameters) => ({
+    attemptId: id("attempt"),
+    dispatchId: id("dispatch"),
+    initialDeliveryId: id("delivery"),
+    runId: id("run"),
+    taskIds: new Map(parameters.graph.tasks.map((task) => [task.clientKey, id("task")])),
+});
+const makeRunCreateCommand = (input, parameters, creation) => commandBase({
+    actorId: input.actorId,
+    aggregateId: creation.runId,
+    aggregateType: ORCHESTRATION_RUN_AGGREGATE_TYPE,
+    commandId: parameters.commandId,
+    eventPayload: {
+        dispatchId: creation.dispatchId,
+        taskCount: parameters.graph.tasks.length,
+        terminalId: parameters.terminalId,
+        workspaceId: parameters.workspaceId,
+    },
+    eventType: "run.created",
+    expectedRevision: 0n,
+    method: "run.create",
+    pointer: {
+        deliveryId: creation.initialDeliveryId,
+        runId: creation.runId,
+    },
+    requestDigest: input.requestDigest,
+});
+const mutateRunCreation = (input) => {
+    insertRunRecords(input);
+    const dispatchTask = input.parameters.graph.tasks.find((task) => task.clientKey === input.parameters.graph.dispatchTaskKey);
+    if (dispatchTask === undefined) {
+        throw makeNodeRuntimeError("storage_corrupt", "The admitted Dispatch Task is missing.");
+    }
+    publishMessage(input.database, {
+        body: dispatchTask.objective,
+        deliveryId: input.initialDeliveryId,
+        owner: { id: input.dispatchId, kind: "dispatch" },
+        runId: input.runId,
+        subject: "Dispatch ready",
+        type: "dispatch",
+    }, input.recordedAt);
+};
+const commitRunCreation = (commit) => {
+    const creation = makeRunCreation(commit.parameters);
+    const mutationInput = { ...commit, ...creation };
+    const result = commitCommandWithMutation({
+        database: commit.database,
+        input: makeRunCreateCommand(commit.input, commit.parameters, creation),
+        mutate: () => {
+            mutateRunCreation(mutationInput);
+            readOrchestrationAggregate(commit.database, creation.runId);
+        },
+        recordedAt: commit.recordedAt,
+    });
+    return runCreateResultFromCommand(commit.database, commit.parameters.commandId, result);
+};
+export const createOrchestrationRun = (database, input, recordedAt) => {
+    requireLocalCoordinatorActor(input.actorId);
+    const parameters = orchestrationRunCreateParametersSchema.parse(input.parameters);
+    inspectOrchestrationRunCreateAdmission(parameters);
+    const existing = findPersistedCommand(database, {
+        actorId: input.actorId,
+        commandId: parameters.commandId,
+        method: "run.create",
+        requestDigest: input.requestDigest,
+    });
+    if (existing !== undefined) {
+        return runCreateResultFromCommand(database, parameters.commandId, existing);
+    }
+    return commitRunCreation({ database, input, parameters, recordedAt });
+};
+export const showOrchestrationRun = (database, runId) => orchestrationRunShowResultSchema.parse({
+    aggregate: readOrchestrationAggregate(database, runId),
+    method: "run.show",
+});
+const listedRunRowSchema = Schema.Struct({
+    ...runRowSchema.fields,
+    sequence: Schema.BigInt,
+});
+const decodeListedRunRow = Schema.decodeUnknownSync(listedRunRowSchema);
+const requireExistingWorkspace = (database, workspaceId) => {
+    const row = database
+        .prepare("SELECT workspace_id AS id FROM workspaces WHERE workspace_id = ?")
+        .get(workspaceId);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("resource_not_found", "The workspace was not found.");
+    }
+};
+const encodedRunListResult = (items, nextCursor) => {
+    const result = orchestrationRunListResultSchema.parse({
+        items,
+        method: "run.list",
+        ...(nextCursor === undefined ? {} : { nextCursor }),
+    });
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") >
+        MAX_ORCHESTRATION_LIST_RESULT_BYTES) {
+        throw makeNodeRuntimeError("frame_too_large", "The orchestration Run list result exceeds the encoded bound.");
+    }
+    return result;
+};
+const readWorkspaceRunPage = (database, parameters) => statementWithBigInts(database, `SELECT sequence, run_id AS id, workspace_id AS workspaceId,
+      terminal_id AS terminalId, root_task_id AS rootTaskId,
+      dispatch_task_id AS dispatchTaskId,
+      coordinator_actor_id AS coordinatorActorId,
+      coordinator_epoch AS coordinatorEpoch, state, revision,
+      message_content_bytes AS messageContentBytes,
+      created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_runs
+     WHERE workspace_id = ? AND sequence > ?
+     ORDER BY sequence LIMIT ?`)
+    .all(parameters.workspaceId, BigInt(parameters.afterCursor), parameters.limit + 1)
+    .map((row) => decodeListedRunRow(row));
+export const listOrchestrationRuns = (database, rawParameters) => {
+    const parameters = orchestrationRunListParametersSchema.parse(rawParameters);
+    requireExistingWorkspace(database, parameters.workspaceId);
+    const rows = readWorkspaceRunPage(database, parameters);
+    const visible = rows.slice(0, parameters.limit);
+    const last = visible.at(-1);
+    return encodedRunListResult(visible.map(runFromRow), rows.length > parameters.limit && last !== undefined
+        ? last.sequence.toString()
+        : undefined);
+};
+const listedTaskRowSchema = Schema.Struct({
+    clientKey: Schema.String,
+    createdAt: Schema.String,
+    id: Schema.String,
+    revision: Schema.BigInt,
+    runId: Schema.String,
+    sequence: Schema.BigInt,
+    state: Schema.String,
+    updatedAt: Schema.String,
+    workspaceId: Schema.String,
+});
+const decodeListedTaskRow = Schema.decodeUnknownSync(listedTaskRowSchema);
+export const encodedOrchestrationTaskListResult = (input) => {
+    if (Buffer.byteLength(JSON.stringify(input), "utf8") >
+        MAX_ORCHESTRATION_TASK_LIST_RESULT_BYTES) {
+        throw makeNodeRuntimeError("frame_too_large", "The orchestration Task list result exceeds the encoded bound.");
+    }
+    const result = orchestrationTaskListResultSchema.parse(input);
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") >
+        MAX_ORCHESTRATION_TASK_LIST_RESULT_BYTES) {
+        throw makeNodeRuntimeError("frame_too_large", "The orchestration Task list result exceeds the encoded bound.");
+    }
+    return result;
+};
+const readRunTaskPage = (database, parameters) => statementWithBigInts(database, `SELECT task_id AS id, run_id AS runId, client_key AS clientKey,
+      workspace_id AS workspaceId, state, revision,
+      created_at AS createdAt, updated_at AS updatedAt, sequence
+     FROM orchestration_tasks
+     WHERE run_id = ? AND sequence > ?
+     ORDER BY sequence
+     LIMIT ?`)
+    .all(parameters.runId, BigInt(parameters.afterCursor), parameters.limit + 1)
+    .map((row) => decodeListedTaskRow(row));
+const readDependencyTaskIdsForTasks = (database, runId, taskIds) => {
+    if (taskIds.length === 0)
+        return new Map();
+    const placeholders = taskIds.map(() => "?").join(", ");
+    const rows = database
+        .prepare(`SELECT d.task_id AS taskId, d.dependency_task_id AS dependencyTaskId
+       FROM orchestration_task_dependencies d
+       WHERE d.run_id = ? AND d.task_id IN (${placeholders})
+       ORDER BY d.task_id, d.position`)
+        .all(runId, ...taskIds)
+        .map((row) => decodeTaskDependencyRow(row));
+    return rows.reduce((grouped, row) => {
+        const dependencyTaskIds = grouped.get(row.taskId) ?? [];
+        dependencyTaskIds.push(row.dependencyTaskId);
+        grouped.set(row.taskId, dependencyTaskIds);
+        return grouped;
+    }, new Map());
+};
+const taskSummaryFromRow = (task, dependencyTaskIdsByTask) => ({
+    clientKey: task.clientKey,
+    createdAt: task.createdAt,
+    dependencyTaskIds: dependencyTaskIdsByTask.get(task.id) ?? [],
+    id: task.id,
+    revision: task.revision.toString(),
+    runId: task.runId,
+    schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+    state: task.state,
+    updatedAt: task.updatedAt,
+    workspaceId: task.workspaceId,
+});
+export const listOrchestrationTasks = (database, rawParameters) => {
+    const parameters = orchestrationTaskListParametersSchema.parse(rawParameters);
+    readRunRow(database, parameters.runId);
+    const rows = readRunTaskPage(database, parameters);
+    const visible = rows.slice(0, parameters.limit);
+    const last = visible.at(-1);
+    const dependencies = readDependencyTaskIdsForTasks(database, parameters.runId, visible.map((item) => item.id));
+    return encodedOrchestrationTaskListResult({
+        items: visible.map((row) => taskSummaryFromRow(row, dependencies)),
+        method: "run.task.list",
+        runId: parameters.runId,
+        ...(rows.length > parameters.limit && last !== undefined
+            ? { nextCursor: last.sequence.toString() }
+            : {}),
+    });
+};
+const readRunTaskRow = (database, parameters) => {
+    const row = statementWithBigInts(database, `SELECT task_id AS id, run_id AS runId, client_key AS clientKey,
+      workspace_id AS workspaceId, objective, state, revision,
+      created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_tasks
+     WHERE run_id = ? AND task_id = ?`).get(parameters.runId, parameters.taskId);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("resource_not_found", "The orchestration Task was not found.");
+    }
+    return decodeTaskRow(row);
+};
+const taskFromShownRow = (task, dependencyTaskIds) => ({
+    clientKey: task.clientKey,
+    createdAt: task.createdAt,
+    dependencyTaskIds,
+    id: task.id,
+    objective: task.objective,
+    revision: task.revision.toString(),
+    runId: task.runId,
+    schemaVersion: ORCHESTRATION_SCHEMA_VERSION,
+    state: task.state,
+    updatedAt: task.updatedAt,
+    workspaceId: task.workspaceId,
+});
+export const encodedOrchestrationTaskShowResult = (input) => {
+    if (Buffer.byteLength(JSON.stringify(input), "utf8") >
+        MAX_ORCHESTRATION_TASK_SHOW_RESULT_BYTES) {
+        throw makeNodeRuntimeError("frame_too_large", "The orchestration Task show result exceeds the encoded bound.");
+    }
+    const result = orchestrationTaskShowResultSchema.parse(input);
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") >
+        MAX_ORCHESTRATION_TASK_SHOW_RESULT_BYTES) {
+        throw makeNodeRuntimeError("frame_too_large", "The orchestration Task show result exceeds the encoded bound.");
+    }
+    return result;
+};
+export const showOrchestrationTask = (database, rawParameters) => {
+    const parameters = orchestrationTaskShowParametersSchema.parse(rawParameters);
+    readRunRow(database, parameters.runId);
+    const row = readRunTaskRow(database, parameters);
+    const dependencies = readDependencyTaskIdsForTasks(database, parameters.runId, [parameters.taskId]);
+    return encodedOrchestrationTaskShowResult({
+        method: "run.task.show",
+        runId: parameters.runId,
+        task: taskFromShownRow(row, dependencies.get(parameters.taskId) ?? []),
+        taskId: parameters.taskId,
+    });
+};
+const readDispatchShowRow = (database, runId) => {
+    const row = statementWithBigInts(database, `SELECT dispatch_id AS id, run_id AS runId, task_id AS taskId,
+      attempt_id AS attemptId, terminal_id AS terminalId, state,
+      failure_code AS failureCode, failure_platform AS failurePlatform,
+      revision, created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_dispatches WHERE run_id = ?`).get(runId);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("resource_not_found", "The orchestration Dispatch was not found.");
+    }
+    return decodeDispatchRow(row);
+};
+export const encodedOrchestrationDispatchShowResult = (input) => {
+    if (Buffer.byteLength(JSON.stringify(input), "utf8") >
+        MAX_ORCHESTRATION_DISPATCH_SHOW_RESULT_BYTES) {
+        throw makeNodeRuntimeError("frame_too_large", "The orchestration Dispatch show result exceeds the encoded bound.");
+    }
+    const result = orchestrationDispatchShowResultSchema.parse(input);
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") >
+        MAX_ORCHESTRATION_DISPATCH_SHOW_RESULT_BYTES) {
+        throw makeNodeRuntimeError("frame_too_large", "The orchestration Dispatch show result exceeds the encoded bound.");
+    }
+    return result;
+};
+export const showOrchestrationDispatch = (database, rawParameters) => {
+    const parameters = orchestrationDispatchShowParametersSchema.parse(rawParameters);
+    readRunRow(database, parameters.runId);
+    return encodedOrchestrationDispatchShowResult({
+        dispatch: dispatchFromRow(readDispatchShowRow(database, parameters.runId)),
+        method: "run.dispatch.show",
+        runId: parameters.runId,
+    });
+};
+const readMailboxById = (database, mailboxId) => {
+    const row = statementWithBigInts(database, `SELECT mailbox_id AS id, run_id AS runId, owner_kind AS ownerKind,
+      owner_id AS ownerId, head_sequence AS headSequence,
+      delivery_count AS deliveryCount, content_bytes AS contentBytes,
+      revision, created_at AS createdAt, updated_at AS updatedAt
+     FROM orchestration_mailboxes WHERE mailbox_id = ?`).get(mailboxId);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("resource_not_found", "The orchestration Mailbox was not found.");
+    }
+    return decodeMailboxRow(row);
+};
+const nextDeliveryRow = (row, recordedAt) => ({
+    ...row,
+    attemptCount: row.attemptCount >= BigInt(MAX_ORCHESTRATION_DELIVERY_ATTEMPTS)
+        ? BigInt(MAX_ORCHESTRATION_DELIVERY_ATTEMPTS)
+        : row.attemptCount + 1n,
+    firstDeliveredAt: row.firstDeliveredAt ?? recordedAt,
+    lastDeliveredAt: recordedAt,
+});
+const encodedInboxResult = (mailbox, rows) => orchestrationInboxCheckResultSchema.parse({
+    items: rows.map(deliveryFromRow),
+    mailbox: mailboxFromRow(mailbox),
+    method: "run.inbox.check",
+});
+const chooseInboxDeliveries = (mailbox, rows, recordedAt) => rows.reduce((selection, row) => {
+    if (selection.full)
+        return selection;
+    const next = nextDeliveryRow(row, recordedAt);
+    const candidate = encodedInboxResult(mailbox, [
+        ...selection.chosen,
+        next,
+    ]);
+    const full = Buffer.byteLength(JSON.stringify(candidate), "utf8") >
+        MAX_ORCHESTRATION_CHECK_RESULT_BYTES;
+    return full
+        ? { chosen: selection.chosen, full }
+        : { chosen: [...selection.chosen, next], full };
+}, { chosen: [], full: false }).chosen;
+const recordDeliveryChecks = (database, rows, recordedAt) => {
+    rows.forEach((row) => {
+        requireOneChange(database
+            .prepare(`UPDATE orchestration_deliveries
+           SET attempt_count = ?, first_delivered_at = COALESCE(first_delivered_at, ?),
+             last_delivered_at = ?
+           WHERE delivery_id = ? AND state = 'pending'`)
+            .run(row.attemptCount, recordedAt, recordedAt, row.id), "The Delivery changed during inbox check.");
+    });
+};
+const requireEncodedInboxBound = (result) => {
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") >
+        MAX_ORCHESTRATION_CHECK_RESULT_BYTES) {
+        throw makeNodeRuntimeError("storage_corrupt", "The bounded inbox check result exceeded its encoded ceiling.");
+    }
+};
+const transactImmediate = (database, operation) => {
+    database.exec("BEGIN IMMEDIATE");
+    try {
+        const result = operation();
+        database.exec("COMMIT");
+        return result;
+    }
+    catch (error) {
+        database.exec("ROLLBACK");
+        throw error;
+    }
+};
+const readPendingDeliveryRows = (database, mailboxId, limit) => statementWithBigInts(database, `${deliverySelect}
+     WHERE d.mailbox_id = ? AND d.state = 'pending'
+     ORDER BY d.mailbox_sequence LIMIT ?`)
+    .all(mailboxId, limit)
+    .map((row) => decodeDeliveryRow(row));
+const checkOrchestrationInboxTransaction = (database, parameters, recordedAt) => {
+    requireCoordinator(database, parameters.runId, parameters.coordinatorEpoch);
+    const mailbox = readMailboxForOwner(database, parameters.runId, parameters.owner);
+    const rows = readPendingDeliveryRows(database, mailbox.id, parameters.limit);
+    const chosen = chooseInboxDeliveries(mailbox, rows, recordedAt);
+    recordDeliveryChecks(database, chosen, recordedAt);
+    const persisted = chosen.map((row) => readOrchestrationDelivery(database, row.id));
+    const result = orchestrationInboxCheckResultSchema.parse({
+        items: persisted,
+        mailbox: mailboxFromRow(mailbox),
+        method: "run.inbox.check",
+    });
+    requireEncodedInboxBound(result);
+    return result;
+};
+export const checkOrchestrationInbox = (database, parameters, recordedAt) => transactImmediate(database, () => checkOrchestrationInboxTransaction(database, parameters, recordedAt));
+const inboxAckResultFromCommand = (database, commandId, result) => {
+    const pointer = readCommandPointer(result);
+    if (pointer.deliveryId === undefined) {
+        throw makeNodeRuntimeError("storage_corrupt", "The inbox acknowledgement Delivery pointer is missing.");
+    }
+    const delivery = readOrchestrationDelivery(database, pointer.deliveryId);
+    return orchestrationInboxAckResultSchema.parse({
+        delivery,
+        mailbox: mailboxFromRow(readMailboxById(database, delivery.mailboxId)),
+        method: "run.inbox.ack",
+        receipt: commandReceiptFromPersisted(commandId, result),
+    });
+};
+const makeInboxAckCommand = (input, mailbox, sourceCommandId) => commandBase({
+    actorId: input.actorId,
+    aggregateId: mailbox.id,
+    aggregateType: ORCHESTRATION_MAILBOX_AGGREGATE_TYPE,
+    commandId: input.parameters.commandId,
+    eventPayload: sourceCommandId === undefined
+        ? {
+            deliveryId: input.parameters.deliveryId,
+            owner: input.parameters.owner,
+            runId: input.parameters.runId,
+        }
+        : { deliveryId: input.parameters.deliveryId, sourceCommandId },
+    eventType: sourceCommandId === undefined
+        ? "delivery.acknowledged"
+        : "delivery.acknowledgement-receipt",
+    expectedRevision: BigInt(input.parameters.expectedMailboxRevision),
+    method: "run.inbox.ack",
+    pointer: {
+        deliveryId: input.parameters.deliveryId,
+        runId: input.parameters.runId,
+    },
+    requestDigest: input.requestDigest,
+});
+const readAckSourceCommandId = (database, deliveryId) => {
+    const row = database
+        .prepare(`SELECT acknowledgement_command_id AS commandId
+       FROM orchestration_deliveries WHERE delivery_id = ?`)
+        .get(deliveryId);
+    return Schema.decodeUnknownSync(Schema.Struct({ commandId: Schema.String }))(row).commandId;
+};
+const requireAckMailbox = (database, input, mailboxId) => {
+    requireCoordinator(database, input.parameters.runId, input.parameters.coordinatorEpoch);
+    const mailbox = readMailboxForOwner(database, input.parameters.runId, input.parameters.owner);
+    if (mailbox.id !== mailboxId ||
+        mailbox.revision !== BigInt(input.parameters.expectedMailboxRevision)) {
+        throw makeNodeRuntimeError("storage_conflict", "The Mailbox revision changed before acknowledgement.", true);
+    }
+    return mailbox;
+};
+const requireAckDelivery = (database, input, mailbox) => {
+    const delivery = readOrchestrationDelivery(database, input.parameters.deliveryId);
+    if (delivery.mailboxId !== mailbox.id) {
+        throw makeNodeRuntimeError("resource_not_found", "The Delivery does not belong to the selected Mailbox.");
+    }
+    return delivery;
+};
+const validateAckReplay = (database, input, mailboxId) => {
+    const mailbox = requireAckMailbox(database, input, mailboxId);
+    const delivery = requireAckDelivery(database, input, mailbox);
+    if (delivery.state !== "acknowledged" ||
+        delivery.acknowledgingActorId !== LOCAL_USER_ACTOR_ID) {
+        throw makeNodeRuntimeError("storage_conflict", "The acknowledged Delivery changed before receipt persistence.", true);
+    }
+};
+const replayInboxAcknowledgement = (commit) => {
+    const sourceCommandId = readAckSourceCommandId(commit.database, commit.input.parameters.deliveryId);
+    const result = commitIdempotentCommandReceipt({
+        database: commit.database,
+        input: makeInboxAckCommand(commit.input, commit.mailbox, sourceCommandId),
+        recordedAt: commit.recordedAt,
+        sourceCommandId,
+        sourceMethod: "run.inbox.ack",
+        validate: () => {
+            validateAckReplay(commit.database, commit.input, commit.mailbox.id);
+        },
+    });
+    return inboxAckResultFromCommand(commit.database, commit.input.parameters.commandId, result);
+};
+const acknowledgePendingDelivery = (mutation, mailbox, delivery) => {
+    if (delivery.state !== "pending")
+        return;
+    requireOneChange(mutation.database
+        .prepare(`UPDATE orchestration_deliveries SET state = 'acknowledged',
+          acknowledging_actor_id = 'actor_local_user',
+          acknowledgement_command_id = ?, acknowledged_at = ?
+         WHERE delivery_id = ? AND mailbox_id = ? AND state = 'pending'`)
+        .run(mutation.input.parameters.commandId, mutation.recordedAt, delivery.id, mailbox.id), "The Delivery changed before acknowledgement.");
+};
+const requireDeliveryAckActor = (delivery) => {
+    if (delivery.state === "acknowledged" &&
+        delivery.acknowledgingActorId !== LOCAL_USER_ACTOR_ID) {
+        throw makeNodeRuntimeError("storage_conflict", "The Delivery was acknowledged by a different actor.");
+    }
+};
+const mutateInboxAcknowledgement = (mutation) => {
+    const mailbox = requireAckMailbox(mutation.database, mutation.input, mutation.mailboxId);
+    const delivery = requireAckDelivery(mutation.database, mutation.input, mailbox);
+    requireDeliveryAckActor(delivery);
+    const nextMailboxRevision = advanceSignedSqliteInteger(mailbox.revision);
+    acknowledgePendingDelivery(mutation, mailbox, delivery);
+    requireOneChange(mutation.database
+        .prepare(`UPDATE orchestration_mailboxes SET revision = ?,
+          updated_at = ? WHERE mailbox_id = ? AND revision = ?`)
+        .run(nextMailboxRevision, mutation.recordedAt, mailbox.id, mailbox.revision), "The Mailbox changed before acknowledgement.");
+};
+const commitInboxAcknowledgement = (commit) => {
+    const result = commitCommandWithMutation({
+        database: commit.database,
+        input: makeInboxAckCommand(commit.input, commit.mailbox),
+        mutate: () => {
+            mutateInboxAcknowledgement({
+                database: commit.database,
+                input: commit.input,
+                mailboxId: commit.mailbox.id,
+                recordedAt: commit.recordedAt,
+            });
+        },
+        recordedAt: commit.recordedAt,
+    });
+    return inboxAckResultFromCommand(commit.database, commit.input.parameters.commandId, result);
+};
+const readInboxAckMailbox = (database, input) => {
+    requireCoordinator(database, input.parameters.runId, input.parameters.coordinatorEpoch);
+    return readMailboxForOwner(database, input.parameters.runId, input.parameters.owner);
+};
+export const acknowledgeOrchestrationDelivery = (database, input, recordedAt) => {
+    requireLocalCoordinatorActor(input.actorId);
+    const existing = findPersistedCommand(database, {
+        actorId: input.actorId,
+        commandId: input.parameters.commandId,
+        method: "run.inbox.ack",
+        requestDigest: input.requestDigest,
+    });
+    if (existing !== undefined) {
+        return inboxAckResultFromCommand(database, input.parameters.commandId, existing);
+    }
+    const mailbox = readInboxAckMailbox(database, input);
+    const delivery = requireAckDelivery(database, input, mailbox);
+    const commit = { database, input, mailbox, recordedAt };
+    return delivery.state === "acknowledged" &&
+        delivery.acknowledgingActorId === LOCAL_USER_ACTOR_ID
+        ? replayInboxAcknowledgement(commit)
+        : commitInboxAcknowledgement(commit);
+};
+//# sourceMappingURL=storage.js.map