@maiaos/protocol 0.1.0-canary.1

package/dist/orchestration/effect-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-schema.d.ts","sourceRoot":"","sources":["../../src/orchestration/effect-schema.ts"],"names":[],"mappings":"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"}

package/dist/orchestration/effect-schema.js

@@ -0,0 +1,610 @@
+import * as Schema from "effect/Schema";
+import { commandReceiptEffectSchema } from "../command-receipt/effect-schema.js";
+import { aggregateRevisionEffectSchema, protocolIdentifierEffectSchema, recordedAtEffectSchema, } from "../envelope/effect-schema.js";
+import { DEFAULT_ORCHESTRATION_CHECK_PAGE_SIZE, DEFAULT_ORCHESTRATION_LIST_PAGE_SIZE, DEFAULT_ORCHESTRATION_TASK_LIST_PAGE_SIZE, MAX_ORCHESTRATION_CHECK_PAGE_SIZE, MAX_ORCHESTRATION_DIRECT_DEPENDENCIES, MAX_ORCHESTRATION_LIST_PAGE_SIZE, MAX_ORCHESTRATION_MESSAGE_BODY_BYTES, MAX_ORCHESTRATION_MESSAGE_SUBJECT_BYTES, MAX_ORCHESTRATION_TASK_LIST_PAGE_SIZE, MAX_ORCHESTRATION_TASK_OBJECTIVE_BYTES, MAX_ORCHESTRATION_TASKS_PER_RUN, } from "./policy.js";
+import { isValidOrchestrationGraphProjection } from "./topology.js";
+/** The Run ledger's graph check, shared with its request schema. */
+export { isValidOrchestrationTaskSetProjection } from "./topology.js";
+import { ORCHESTRATION_MESSAGE_SCHEMA_VERSION, ORCHESTRATION_SCHEMA_VERSION, } from "./version.js";
+const utf8 = new TextEncoder();
+const bytesBetween = (minimum, maximum, expected) => Schema.String.check(Schema.makeFilter((value) => {
+    const length = utf8.encode(value).byteLength;
+    return length >= minimum && length <= maximum;
+}, { expected }));
+const clientKeyEffectSchema = Schema.String.check(Schema.isBetweenLength(1, 64), Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9_-]*$/u));
+const taskObjectiveEffectSchema = bytesBetween(1, MAX_ORCHESTRATION_TASK_OBJECTIVE_BYTES, "a Task objective encoded as 1 to 4096 UTF-8 bytes");
+const messageSubjectEffectSchema = bytesBetween(1, MAX_ORCHESTRATION_MESSAGE_SUBJECT_BYTES, "a Message subject encoded as 1 to 128 UTF-8 bytes");
+const messageBodyEffectSchema = bytesBetween(1, MAX_ORCHESTRATION_MESSAGE_BODY_BYTES, "a Message body encoded as 1 to 4096 UTF-8 bytes");
+const coordinatorEpochEffectSchema = Schema.Literal(1);
+const runMailboxOwnerEffectSchema = Schema.Struct({
+    id: protocolIdentifierEffectSchema,
+    kind: Schema.Literal("run"),
+});
+const dispatchMailboxOwnerEffectSchema = Schema.Struct({
+    id: protocolIdentifierEffectSchema,
+    kind: Schema.Literal("dispatch"),
+});
+const mailboxOwnerEffectSchema = Schema.Union([
+    runMailboxOwnerEffectSchema,
+    dispatchMailboxOwnerEffectSchema,
+]);
+export const orchestrationTaskInputEffectSchema = Schema.Struct({
+    clientKey: clientKeyEffectSchema,
+    dependsOn: Schema.Array(clientKeyEffectSchema).check(Schema.isMaxLength(MAX_ORCHESTRATION_DIRECT_DEPENDENCIES)),
+    objective: taskObjectiveEffectSchema,
+});
+export const orchestrationTaskGraphEffectSchema = Schema.Struct({
+    dispatchTaskKey: clientKeyEffectSchema,
+    rootTaskKey: clientKeyEffectSchema,
+    tasks: Schema.Array(orchestrationTaskInputEffectSchema).check(Schema.isMinLength(1), Schema.isMaxLength(MAX_ORCHESTRATION_TASKS_PER_RUN)),
+});
+const orchestrationTaskSummaryFields = {
+    clientKey: clientKeyEffectSchema,
+    createdAt: recordedAtEffectSchema,
+    dependencyTaskIds: Schema.Array(protocolIdentifierEffectSchema).check(Schema.isMaxLength(MAX_ORCHESTRATION_DIRECT_DEPENDENCIES)),
+    id: protocolIdentifierEffectSchema,
+    revision: aggregateRevisionEffectSchema,
+    runId: protocolIdentifierEffectSchema,
+    schemaVersion: Schema.Literal(ORCHESTRATION_SCHEMA_VERSION),
+    state: Schema.Literals(["pending", "active", "waiting-question", "failed"]),
+    updatedAt: recordedAtEffectSchema,
+    workspaceId: protocolIdentifierEffectSchema,
+};
+export const orchestrationTaskSummaryEffectSchema = Schema.Struct(orchestrationTaskSummaryFields);
+export const orchestrationTaskEffectSchema = Schema.Struct({
+    ...orchestrationTaskSummaryFields,
+    objective: taskObjectiveEffectSchema,
+});
+export const orchestrationRunEffectSchema = Schema.Struct({
+    coordinator: Schema.Struct({
+        actorId: Schema.Literal("actor_local_user"),
+        epoch: coordinatorEpochEffectSchema,
+    }),
+    createdAt: recordedAtEffectSchema,
+    dispatchTaskId: protocolIdentifierEffectSchema,
+    id: protocolIdentifierEffectSchema,
+    revision: aggregateRevisionEffectSchema,
+    rootTaskId: protocolIdentifierEffectSchema,
+    schemaVersion: Schema.Literal(ORCHESTRATION_SCHEMA_VERSION),
+    state: Schema.Literals(["active", "waiting-question", "failed"]),
+    terminalId: protocolIdentifierEffectSchema,
+    updatedAt: recordedAtEffectSchema,
+    workspaceId: protocolIdentifierEffectSchema,
+});
+export const orchestrationAttemptEffectSchema = Schema.Struct({
+    createdAt: recordedAtEffectSchema,
+    id: protocolIdentifierEffectSchema,
+    ordinal: Schema.Literal(1),
+    revision: aggregateRevisionEffectSchema,
+    runId: protocolIdentifierEffectSchema,
+    schemaVersion: Schema.Literal(ORCHESTRATION_SCHEMA_VERSION),
+    state: Schema.Literals(["active", "waiting-question", "failed"]),
+    taskId: protocolIdentifierEffectSchema,
+    updatedAt: recordedAtEffectSchema,
+});
+const terminalFailureEffectSchema = Schema.Union([
+    Schema.Struct({
+        code: Schema.Literal("terminal_containment_unsupported"),
+        platform: Schema.Literals(["darwin", "linux"]),
+    }),
+    Schema.Struct({
+        code: Schema.Literal("platform_unsupported"),
+        platform: Schema.Literals(["win32", "other"]),
+    }),
+]);
+const orchestrationDispatchFields = {
+    attemptId: protocolIdentifierEffectSchema,
+    createdAt: recordedAtEffectSchema,
+    id: protocolIdentifierEffectSchema,
+    revision: aggregateRevisionEffectSchema,
+    runId: protocolIdentifierEffectSchema,
+    schemaVersion: Schema.Literal(ORCHESTRATION_SCHEMA_VERSION),
+    taskId: protocolIdentifierEffectSchema,
+    terminalId: protocolIdentifierEffectSchema,
+    updatedAt: recordedAtEffectSchema,
+};
+export const orchestrationDispatchEffectSchema = Schema.Union([
+    Schema.Struct({
+        ...orchestrationDispatchFields,
+        state: Schema.Literal("active"),
+    }),
+    Schema.Struct({
+        ...orchestrationDispatchFields,
+        state: Schema.Literal("waiting-question"),
+    }),
+    Schema.Struct({
+        ...orchestrationDispatchFields,
+        failure: terminalFailureEffectSchema,
+        state: Schema.Literal("failed"),
+    }),
+]);
+const orchestrationMailboxStructEffectSchema = Schema.Struct({
+    contentBytes: aggregateRevisionEffectSchema,
+    createdAt: recordedAtEffectSchema,
+    deliveryCount: aggregateRevisionEffectSchema,
+    headSequence: aggregateRevisionEffectSchema,
+    id: protocolIdentifierEffectSchema,
+    owner: mailboxOwnerEffectSchema,
+    revision: aggregateRevisionEffectSchema,
+    runId: protocolIdentifierEffectSchema,
+    schemaVersion: Schema.Literal(ORCHESTRATION_SCHEMA_VERSION),
+    updatedAt: recordedAtEffectSchema,
+});
+export const orchestrationMailboxEffectSchema = orchestrationMailboxStructEffectSchema.check(Schema.makeFilter((mailbox) => mailbox.owner.kind === "dispatch" || mailbox.owner.id === mailbox.runId, { expected: "a run Mailbox owned by its exact Run" }));
+const orchestrationMessageFields = {
+    body: messageBodyEffectSchema,
+    createdAt: recordedAtEffectSchema,
+    digest: Schema.String.check(Schema.isBetweenLength(64, 64), Schema.isPattern(/^[a-f0-9]{64}$/u)),
+    id: protocolIdentifierEffectSchema,
+    runId: protocolIdentifierEffectSchema,
+    schemaVersion: Schema.Literal(ORCHESTRATION_MESSAGE_SCHEMA_VERSION),
+    sender: Schema.Struct({
+        actorId: Schema.Literal("actor_local_user"),
+        kind: Schema.Literal("run-coordinator"),
+        runId: protocolIdentifierEffectSchema,
+    }),
+    subject: messageSubjectEffectSchema,
+};
+const orchestrationMessageVariantEffectSchema = Schema.Union([
+    Schema.Struct({
+        ...orchestrationMessageFields,
+        recipient: dispatchMailboxOwnerEffectSchema,
+        type: Schema.Literal("dispatch"),
+    }),
+    Schema.Struct({
+        ...orchestrationMessageFields,
+        questionId: protocolIdentifierEffectSchema,
+        recipient: runMailboxOwnerEffectSchema,
+        type: Schema.Literal("question"),
+    }),
+    Schema.Struct({
+        ...orchestrationMessageFields,
+        questionId: protocolIdentifierEffectSchema,
+        recipient: dispatchMailboxOwnerEffectSchema,
+        type: Schema.Literal("reply"),
+    }),
+    Schema.Struct({
+        ...orchestrationMessageFields,
+        recipient: runMailboxOwnerEffectSchema,
+        type: Schema.Literal("dispatch-settled"),
+    }),
+]);
+export const orchestrationMessageEffectSchema = orchestrationMessageVariantEffectSchema.check(Schema.makeFilter((message) => message.sender.runId === message.runId &&
+    (message.recipient.kind === "dispatch" ||
+        message.recipient.id === message.runId), { expected: "a Message whose Run identities are exact" }));
+const orchestrationDeliveryFields = {
+    attemptCount: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(65_535)),
+    createdAt: recordedAtEffectSchema,
+    firstDeliveredAt: Schema.optional(recordedAtEffectSchema),
+    id: protocolIdentifierEffectSchema,
+    lastDeliveredAt: Schema.optional(recordedAtEffectSchema),
+    mailboxId: protocolIdentifierEffectSchema,
+    message: orchestrationMessageEffectSchema,
+    sequence: aggregateRevisionEffectSchema,
+};
+export const orchestrationPendingDeliveryEffectSchema = Schema.Struct({
+    ...orchestrationDeliveryFields,
+    state: Schema.Literal("pending"),
+});
+export const orchestrationAcknowledgedDeliveryEffectSchema = Schema.Struct({
+    ...orchestrationDeliveryFields,
+    acknowledgedAt: recordedAtEffectSchema,
+    acknowledgingActorId: Schema.Literal("actor_local_user"),
+    state: Schema.Literal("acknowledged"),
+});
+export const orchestrationDeliveryEffectSchema = Schema.Union([
+    orchestrationPendingDeliveryEffectSchema,
+    orchestrationAcknowledgedDeliveryEffectSchema,
+]);
+const orchestrationQuestionFields = {
+    askMessageId: protocolIdentifierEffectSchema,
+    attemptId: protocolIdentifierEffectSchema,
+    body: messageBodyEffectSchema,
+    createdAt: recordedAtEffectSchema,
+    dispatchId: protocolIdentifierEffectSchema,
+    id: protocolIdentifierEffectSchema,
+    revision: aggregateRevisionEffectSchema,
+    runId: protocolIdentifierEffectSchema,
+    schemaVersion: Schema.Literal(ORCHESTRATION_SCHEMA_VERSION),
+    subject: messageSubjectEffectSchema,
+    taskId: protocolIdentifierEffectSchema,
+    updatedAt: recordedAtEffectSchema,
+};
+export const orchestrationQuestionEffectSchema = Schema.Union([
+    Schema.Struct({
+        ...orchestrationQuestionFields,
+        state: Schema.Literal("open"),
+    }),
+    Schema.Struct({
+        ...orchestrationQuestionFields,
+        answer: messageBodyEffectSchema,
+        replyMessageId: protocolIdentifierEffectSchema,
+        state: Schema.Literal("answered"),
+    }),
+    Schema.Struct({
+        ...orchestrationQuestionFields,
+        state: Schema.Literal("cancelled"),
+    }),
+]);
+const orchestrationAggregateStructEffectSchema = Schema.Struct({
+    attempt: orchestrationAttemptEffectSchema,
+    dispatch: orchestrationDispatchEffectSchema,
+    mailboxes: Schema.Array(orchestrationMailboxEffectSchema).check(Schema.isBetweenLength(2, 2)),
+    question: Schema.optional(orchestrationQuestionEffectSchema),
+    run: orchestrationRunEffectSchema,
+    tasks: Schema.Array(orchestrationTaskEffectSchema).check(Schema.isMinLength(1), Schema.isMaxLength(MAX_ORCHESTRATION_TASKS_PER_RUN)),
+});
+const hasExactMailboxOwners = (aggregate) => {
+    const runMailboxes = aggregate.mailboxes.filter((mailbox) => mailbox.runId === aggregate.run.id &&
+        mailbox.owner.kind === "run" &&
+        mailbox.owner.id === aggregate.run.id);
+    const dispatchMailboxes = aggregate.mailboxes.filter((mailbox) => mailbox.runId === aggregate.run.id &&
+        mailbox.owner.kind === "dispatch" &&
+        mailbox.owner.id === aggregate.dispatch.id);
+    return runMailboxes.length === 1 && dispatchMailboxes.length === 1;
+};
+const hasExactTaskScope = (aggregate) => {
+    const taskIds = new Set(aggregate.tasks.map((task) => task.id));
+    return aggregate.tasks.every((task) => task.runId === aggregate.run.id &&
+        task.workspaceId === aggregate.run.workspaceId &&
+        task.dependencyTaskIds.every((dependencyId) => taskIds.has(dependencyId)));
+};
+const hasAdmittedTaskGraph = (aggregate) => isValidOrchestrationGraphProjection({
+    dispatchTaskKey: aggregate.run.dispatchTaskId,
+    rootTaskKey: aggregate.run.rootTaskId,
+    tasks: aggregate.tasks.map((task) => ({
+        clientKey: task.id,
+        dependsOn: task.dependencyTaskIds,
+        objective: task.objective,
+    })),
+});
+const hasUniqueAggregateIdentities = (aggregate) => new Set(aggregate.tasks.map((task) => task.id)).size ===
+    aggregate.tasks.length &&
+    new Set(aggregate.tasks.map((task) => task.clientKey)).size ===
+        aggregate.tasks.length &&
+    new Set(aggregate.mailboxes.map((mailbox) => mailbox.id)).size ===
+        aggregate.mailboxes.length;
+const hasExactQuestionScope = (aggregate, selectedTaskId) => aggregate.question === undefined ||
+    (aggregate.question.runId === aggregate.run.id &&
+        aggregate.question.taskId === selectedTaskId &&
+        aggregate.question.attemptId === aggregate.attempt.id &&
+        aggregate.question.dispatchId === aggregate.dispatch.id);
+const hasExactAggregateIdentity = (aggregate) => {
+    const selected = aggregate.tasks.find((task) => task.id === aggregate.run.dispatchTaskId);
+    const root = aggregate.tasks.find((task) => task.id === aggregate.run.rootTaskId);
+    return (selected !== undefined &&
+        root !== undefined &&
+        aggregate.attempt.runId === aggregate.run.id &&
+        aggregate.attempt.taskId === selected.id &&
+        aggregate.dispatch.runId === aggregate.run.id &&
+        aggregate.dispatch.attemptId === aggregate.attempt.id &&
+        aggregate.dispatch.taskId === selected.id &&
+        aggregate.dispatch.terminalId === aggregate.run.terminalId &&
+        hasAdmittedTaskGraph(aggregate) &&
+        hasUniqueAggregateIdentities(aggregate) &&
+        hasExactTaskScope(aggregate) &&
+        hasExactQuestionScope(aggregate, selected.id) &&
+        hasExactMailboxOwners(aggregate));
+};
+const hasFailedLifecycle = (aggregate, coordinatedStates) => coordinatedStates.every((state) => state === "failed") &&
+    aggregate.tasks.every((task) => task.state === "failed") &&
+    aggregate.question?.state !== "open";
+const hasWaitingLifecycle = (aggregate, coordinatedStates, selectedTaskId) => coordinatedStates.every((state) => state === "waiting-question") &&
+    aggregate.tasks.every((task) => task.id === selectedTaskId || task.state === "pending") &&
+    aggregate.question?.state === "open";
+const hasActiveLifecycle = (aggregate, coordinatedStates, selectedTaskId) => coordinatedStates.every((state) => state === "active") &&
+    aggregate.tasks.every((task) => task.id === selectedTaskId || task.state === "pending") &&
+    aggregate.question?.state !== "open";
+const hasExactAggregateLifecycle = (aggregate) => {
+    const selected = aggregate.tasks.find((task) => task.id === aggregate.run.dispatchTaskId);
+    if (selected === undefined)
+        return false;
+    const coordinatedStates = [
+        aggregate.run.state,
+        aggregate.attempt.state,
+        aggregate.dispatch.state,
+        selected.state,
+    ];
+    if (aggregate.run.state === "failed") {
+        return hasFailedLifecycle(aggregate, coordinatedStates);
+    }
+    if (aggregate.run.state === "waiting-question") {
+        return hasWaitingLifecycle(aggregate, coordinatedStates, selected.id);
+    }
+    return hasActiveLifecycle(aggregate, coordinatedStates, selected.id);
+};
+export const orchestrationAggregateEffectSchema = orchestrationAggregateStructEffectSchema.check(Schema.makeFilter((aggregate) => hasExactAggregateIdentity(aggregate) &&
+    hasExactAggregateLifecycle(aggregate), { expected: "an exact local-v1 orchestration aggregate topology" }));
+export const orchestrationRunCreateParametersEffectSchema = Schema.Struct({
+    commandId: protocolIdentifierEffectSchema,
+    expectedRevision: Schema.Literal("0"),
+    graph: orchestrationTaskGraphEffectSchema,
+    terminalId: protocolIdentifierEffectSchema,
+    workspaceId: protocolIdentifierEffectSchema,
+});
+export const orchestrationRunShowParametersEffectSchema = Schema.Struct({
+    runId: protocolIdentifierEffectSchema,
+});
+export const orchestrationRunListParametersEffectSchema = Schema.Struct({
+    afterCursor: aggregateRevisionEffectSchema,
+    limit: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(MAX_ORCHESTRATION_LIST_PAGE_SIZE)),
+    workspaceId: protocolIdentifierEffectSchema,
+});
+export const orchestrationTaskListParametersEffectSchema = Schema.Struct({
+    afterCursor: aggregateRevisionEffectSchema,
+    limit: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(MAX_ORCHESTRATION_TASK_LIST_PAGE_SIZE)),
+    runId: protocolIdentifierEffectSchema,
+});
+export const orchestrationTaskShowParametersEffectSchema = Schema.Struct({
+    runId: protocolIdentifierEffectSchema,
+    taskId: protocolIdentifierEffectSchema,
+});
+export const orchestrationDispatchShowParametersEffectSchema = Schema.Struct({
+    runId: protocolIdentifierEffectSchema,
+});
+export const orchestrationInboxCheckParametersEffectSchema = Schema.Struct({
+    coordinatorEpoch: coordinatorEpochEffectSchema,
+    limit: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(MAX_ORCHESTRATION_CHECK_PAGE_SIZE)),
+    owner: mailboxOwnerEffectSchema,
+    runId: protocolIdentifierEffectSchema,
+});
+export const orchestrationInboxAckParametersEffectSchema = Schema.Struct({
+    commandId: protocolIdentifierEffectSchema,
+    coordinatorEpoch: coordinatorEpochEffectSchema,
+    deliveryId: protocolIdentifierEffectSchema,
+    expectedMailboxRevision: aggregateRevisionEffectSchema,
+    owner: mailboxOwnerEffectSchema,
+    runId: protocolIdentifierEffectSchema,
+});
+const questionMutationBase = {
+    commandId: protocolIdentifierEffectSchema,
+    coordinatorEpoch: coordinatorEpochEffectSchema,
+    dispatchId: protocolIdentifierEffectSchema,
+    expectedDispatchRevision: aggregateRevisionEffectSchema,
+    expectedRunRevision: aggregateRevisionEffectSchema,
+    runId: protocolIdentifierEffectSchema,
+};
+export const orchestrationQuestionOpenParametersEffectSchema = Schema.Struct({
+    ...questionMutationBase,
+    body: messageBodyEffectSchema,
+    subject: messageSubjectEffectSchema,
+});
+export const orchestrationQuestionReplyParametersEffectSchema = Schema.Struct({
+    ...questionMutationBase,
+    answer: messageBodyEffectSchema,
+    expectedQuestionRevision: aggregateRevisionEffectSchema,
+    questionId: protocolIdentifierEffectSchema,
+});
+export const orchestrationQuestionCancelParametersEffectSchema = Schema.Struct({
+    ...questionMutationBase,
+    expectedQuestionRevision: aggregateRevisionEffectSchema,
+    questionId: protocolIdentifierEffectSchema,
+});
+export const orchestrationDispatchSettleTerminalParametersEffectSchema = Schema.Struct(questionMutationBase);
+const receiptMatchesResult = (input) => input.receipt.actorId === "actor_local_user" &&
+    input.receipt.method === input.method &&
+    input.receipt.target.type === input.targetType &&
+    input.receipt.target.id === input.targetId;
+const deliveryMatchesMailbox = (delivery, mailbox) => delivery.mailboxId === mailbox.id &&
+    delivery.message.runId === mailbox.runId &&
+    delivery.message.recipient.kind === mailbox.owner.kind &&
+    delivery.message.recipient.id === mailbox.owner.id;
+const deliveryMatchesAggregateMailbox = (input) => {
+    const ownerId = input.ownerKind === "run"
+        ? input.aggregate.run.id
+        : input.aggregate.dispatch.id;
+    const mailbox = input.aggregate.mailboxes.find((candidate) => candidate.owner.kind === input.ownerKind &&
+        candidate.owner.id === ownerId);
+    return (mailbox !== undefined &&
+        input.delivery.message.type === input.messageType &&
+        deliveryMatchesMailbox(input.delivery, mailbox));
+};
+const orchestrationRunCreateResultStructEffectSchema = Schema.Struct({
+    aggregate: orchestrationAggregateEffectSchema,
+    delivery: Schema.Literals(["new", "duplicate"]),
+    initialDelivery: orchestrationDeliveryEffectSchema,
+    method: Schema.Literal("run.create"),
+    receipt: commandReceiptEffectSchema,
+});
+export const orchestrationRunCreateResultEffectSchema = orchestrationRunCreateResultStructEffectSchema.check(Schema.makeFilter((result) => deliveryMatchesAggregateMailbox({
+    aggregate: result.aggregate,
+    delivery: result.initialDelivery,
+    messageType: "dispatch",
+    ownerKind: "dispatch",
+}) &&
+    receiptMatchesResult({
+        method: result.method,
+        receipt: result.receipt,
+        targetId: result.aggregate.run.id,
+        targetType: "orchestration-run",
+    }), { expected: "a Run-create Delivery matching its Dispatch Mailbox" }));
+export const orchestrationRunShowResultEffectSchema = Schema.Struct({
+    aggregate: orchestrationAggregateEffectSchema,
+    method: Schema.Literal("run.show"),
+});
+const orchestrationRunListResultStructEffectSchema = Schema.Struct({
+    items: Schema.Array(orchestrationRunEffectSchema).check(Schema.isMaxLength(MAX_ORCHESTRATION_LIST_PAGE_SIZE)),
+    method: Schema.Literal("run.list"),
+    nextCursor: Schema.optional(aggregateRevisionEffectSchema),
+});
+export const orchestrationRunListResultEffectSchema = orchestrationRunListResultStructEffectSchema.check(Schema.makeFilter((result) => result.items.every((run) => run.workspaceId === result.items[0]?.workspaceId), { expected: "Run list items that share one Workspace ID" }));
+const orchestrationTaskListResultStructEffectSchema = Schema.Struct({
+    items: Schema.Array(orchestrationTaskSummaryEffectSchema).check(Schema.isMaxLength(MAX_ORCHESTRATION_TASK_LIST_PAGE_SIZE)),
+    method: Schema.Literal("run.task.list"),
+    nextCursor: Schema.optional(aggregateRevisionEffectSchema),
+    runId: protocolIdentifierEffectSchema,
+});
+export const orchestrationTaskListResultEffectSchema = orchestrationTaskListResultStructEffectSchema.check(Schema.makeFilter((result) => result.items.every((task) => task.runId === result.runId), { expected: "Task list items that share the requested Run ID" }));
+const orchestrationTaskShowResultStructEffectSchema = Schema.Struct({
+    method: Schema.Literal("run.task.show"),
+    runId: protocolIdentifierEffectSchema,
+    task: orchestrationTaskEffectSchema,
+    taskId: protocolIdentifierEffectSchema,
+});
+export const orchestrationTaskShowResultEffectSchema = orchestrationTaskShowResultStructEffectSchema.check(Schema.makeFilter((result) => result.task.runId === result.runId && result.task.id === result.taskId, {
+    expected: "a Task show result whose Task IDs match the requested Run and Task",
+}));
+const orchestrationDispatchShowResultStructEffectSchema = Schema.Struct({
+    dispatch: orchestrationDispatchEffectSchema,
+    method: Schema.Literal("run.dispatch.show"),
+    runId: protocolIdentifierEffectSchema,
+});
+export const orchestrationDispatchShowResultEffectSchema = orchestrationDispatchShowResultStructEffectSchema.check(Schema.makeFilter((result) => result.dispatch.runId === result.runId, {
+    expected: "a Dispatch show result whose Dispatch Run ID matches the requested Run",
+}));
+const orchestrationInboxCheckResultStructEffectSchema = Schema.Struct({
+    items: Schema.Array(orchestrationPendingDeliveryEffectSchema).check(Schema.isMaxLength(MAX_ORCHESTRATION_CHECK_PAGE_SIZE)),
+    mailbox: orchestrationMailboxEffectSchema,
+    method: Schema.Literal("run.inbox.check"),
+});
+export const orchestrationInboxCheckResultEffectSchema = orchestrationInboxCheckResultStructEffectSchema.check(Schema.makeFilter((result) => result.items.every((delivery) => deliveryMatchesMailbox(delivery, result.mailbox)), { expected: "inbox-check Deliveries matching the selected Mailbox" }));
+const orchestrationInboxAckResultStructEffectSchema = Schema.Struct({
+    delivery: orchestrationAcknowledgedDeliveryEffectSchema,
+    mailbox: orchestrationMailboxEffectSchema,
+    method: Schema.Literal("run.inbox.ack"),
+    receipt: commandReceiptEffectSchema,
+});
+export const orchestrationInboxAckResultEffectSchema = orchestrationInboxAckResultStructEffectSchema.check(Schema.makeFilter((result) => deliveryMatchesMailbox(result.delivery, result.mailbox), {
+    expected: "an inbox acknowledgement matching its Mailbox",
+}), Schema.makeFilter((result) => receiptMatchesResult({
+    method: result.method,
+    receipt: result.receipt,
+    targetId: result.mailbox.id,
+    targetType: "orchestration-mailbox",
+}), { expected: "an inbox acknowledgement matching its Mailbox" }));
+const questionMutationResultFields = {
+    aggregate: orchestrationAggregateEffectSchema,
+    receipt: commandReceiptEffectSchema,
+};
+const orchestrationQuestionOpenResultStructEffectSchema = Schema.Struct({
+    ...questionMutationResultFields,
+    delivery: orchestrationDeliveryEffectSchema,
+    method: Schema.Literal("run.question.open"),
+});
+export const orchestrationQuestionOpenResultEffectSchema = orchestrationQuestionOpenResultStructEffectSchema.check(Schema.makeFilter((result) => deliveryMatchesAggregateMailbox({
+    aggregate: result.aggregate,
+    delivery: result.delivery,
+    messageType: "question",
+    ownerKind: "run",
+}) &&
+    receiptMatchesResult({
+        method: result.method,
+        receipt: result.receipt,
+        targetId: result.aggregate.run.id,
+        targetType: "orchestration-run",
+    }), { expected: "a Question-open Delivery matching the Run Mailbox" }));
+const orchestrationQuestionReplyResultStructEffectSchema = Schema.Struct({
+    ...questionMutationResultFields,
+    delivery: orchestrationDeliveryEffectSchema,
+    method: Schema.Literal("run.question.reply"),
+});
+export const orchestrationQuestionReplyResultEffectSchema = orchestrationQuestionReplyResultStructEffectSchema.check(Schema.makeFilter((result) => deliveryMatchesAggregateMailbox({
+    aggregate: result.aggregate,
+    delivery: result.delivery,
+    messageType: "reply",
+    ownerKind: "dispatch",
+}) &&
+    receiptMatchesResult({
+        method: result.method,
+        receipt: result.receipt,
+        targetId: result.aggregate.run.id,
+        targetType: "orchestration-run",
+    }), { expected: "a Question-reply Delivery matching the Dispatch Mailbox" }));
+const orchestrationQuestionCancelResultStructEffectSchema = Schema.Struct({
+    ...questionMutationResultFields,
+    method: Schema.Literal("run.question.cancel"),
+});
+export const orchestrationQuestionCancelResultEffectSchema = orchestrationQuestionCancelResultStructEffectSchema.check(Schema.makeFilter((result) => receiptMatchesResult({
+    method: result.method,
+    receipt: result.receipt,
+    targetId: result.aggregate.run.id,
+    targetType: "orchestration-run",
+}), { expected: "a Question-cancel receipt matching its Run" }));
+const orchestrationDispatchSettleTerminalResultStructEffectSchema = Schema.Struct({
+    aggregate: orchestrationAggregateEffectSchema,
+    delivery: orchestrationDeliveryEffectSchema,
+    method: Schema.Literal("run.dispatch.settle-terminal"),
+    receipt: commandReceiptEffectSchema,
+});
+export const orchestrationDispatchSettleTerminalResultEffectSchema = orchestrationDispatchSettleTerminalResultStructEffectSchema.check(Schema.makeFilter((result) => deliveryMatchesAggregateMailbox({
+    aggregate: result.aggregate,
+    delivery: result.delivery,
+    messageType: "dispatch-settled",
+    ownerKind: "run",
+}) &&
+    receiptMatchesResult({
+        method: result.method,
+        receipt: result.receipt,
+        targetId: result.aggregate.run.id,
+        targetType: "orchestration-run",
+    }), { expected: "a Dispatch settlement matching the Run Mailbox" }));
+export const orchestrationRequestPayloadEffectSchema = Schema.Union([
+    Schema.Struct({
+        method: Schema.Literal("run.create"),
+        parameters: orchestrationRunCreateParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.list"),
+        parameters: orchestrationRunListParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.show"),
+        parameters: orchestrationRunShowParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.task.list"),
+        parameters: orchestrationTaskListParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.task.show"),
+        parameters: orchestrationTaskShowParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.dispatch.show"),
+        parameters: orchestrationDispatchShowParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.inbox.check"),
+        parameters: orchestrationInboxCheckParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.inbox.ack"),
+        parameters: orchestrationInboxAckParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.question.open"),
+        parameters: orchestrationQuestionOpenParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.question.reply"),
+        parameters: orchestrationQuestionReplyParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.question.cancel"),
+        parameters: orchestrationQuestionCancelParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("run.dispatch.settle-terminal"),
+        parameters: orchestrationDispatchSettleTerminalParametersEffectSchema,
+    }),
+]);
+export const orchestrationSuccessResultEffectSchema = Schema.Union([
+    orchestrationRunCreateResultEffectSchema,
+    orchestrationRunListResultEffectSchema,
+    orchestrationRunShowResultEffectSchema,
+    orchestrationTaskListResultEffectSchema,
+    orchestrationTaskShowResultEffectSchema,
+    orchestrationDispatchShowResultEffectSchema,
+    orchestrationInboxCheckResultEffectSchema,
+    orchestrationInboxAckResultEffectSchema,
+    orchestrationQuestionOpenResultEffectSchema,
+    orchestrationQuestionReplyResultEffectSchema,
+    orchestrationQuestionCancelResultEffectSchema,
+    orchestrationDispatchSettleTerminalResultEffectSchema,
+]);
+export const orchestrationDefaults = {
+    checkPageSize: DEFAULT_ORCHESTRATION_CHECK_PAGE_SIZE,
+    listPageSize: DEFAULT_ORCHESTRATION_LIST_PAGE_SIZE,
+    taskListPageSize: DEFAULT_ORCHESTRATION_TASK_LIST_PAGE_SIZE,
+};
+//# sourceMappingURL=effect-schema.js.map