@rikalabs/akter 0.1.0-alpha.0

package/dist/protocol/inspection.js

@@ -0,0 +1,243 @@
+import { Schema } from "effect";
+/** A stored value: its JSON, or the text when it could not be decoded. */
+export const Decoded = Schema.Union([
+    Schema.Struct({ json: Schema.Json }),
+    Schema.Struct({ undecodable: Schema.String }),
+]);
+const Stored = Schema.NullOr(Decoded);
+const Millis = Schema.Finite;
+const Identity = { actorType: Schema.String, actorId: Schema.String };
+/**
+ * A tenant's view versions and row counts, and when its soonest pending timer
+ * is due in epoch milliseconds, null when it has none.
+ */
+export const Overview = Schema.Struct({
+    tenant: Schema.String,
+    views: Schema.Array(Schema.Struct({ view: Schema.String, version: Schema.Finite })),
+    counts: Schema.Struct({
+        actors: Schema.Finite,
+        receipts: Schema.Finite,
+        events: Schema.Finite,
+        outbox: Schema.Finite,
+        timers: Schema.Finite,
+        jobs: Schema.Finite,
+        deadLetters: Schema.Finite,
+        workflows: Schema.Finite,
+        openWorkflows: Schema.Finite,
+    }),
+    nextTimerDueAtMs: Schema.NullOr(Millis),
+});
+/** One actor with its placement, generation and last event sequence. */
+export const ActorRow = Schema.Struct({
+    ...Identity,
+    placement: Schema.NullOr(Schema.String),
+    generation: Schema.Finite,
+    created: Schema.Boolean,
+    lastEventSequence: Schema.Finite,
+});
+/** A page of actors; `next` is the identity to continue from, or null at the end. */
+export const ActorsPage = Schema.Struct({
+    actors: Schema.Array(ActorRow),
+    next: Schema.NullOr(Schema.Struct(Identity)),
+});
+/** A staged intent with its target, attempts, last error and due time in epoch milliseconds. */
+export const OutboxRow = Schema.Struct({
+    ...Identity,
+    intentId: Schema.String,
+    timerKey: Schema.NullOr(Schema.String),
+    targetType: Schema.String,
+    targetId: Schema.String,
+    command: Schema.String,
+    payload: Stored,
+    caller: Stored,
+    attempts: Schema.Finite,
+    lastError: Schema.NullOr(Schema.String),
+    dueAtMs: Millis,
+});
+/**
+ * A pending job with its attempts, last error, due time in epoch
+ * milliseconds and whether an earlier attempt's outcome is ambiguous.
+ */
+export const JobRow = Schema.Struct({
+    ...Identity,
+    jobId: Schema.String,
+    job: Schema.String,
+    payload: Stored,
+    caller: Stored,
+    attempts: Schema.Finite,
+    lastError: Schema.NullOr(Schema.String),
+    ambiguous: Schema.Boolean,
+    dueAtMs: Millis,
+});
+/** A job that gave up, with its cause and the epoch millisecond it died. */
+export const DeadLetterRow = Schema.Struct({
+    ...Identity,
+    jobId: Schema.String,
+    job: Schema.String,
+    payload: Stored,
+    attempts: Schema.Finite,
+    cause: Schema.String,
+    ambiguous: Schema.Boolean,
+    deadAtMs: Millis,
+});
+/** One attempt of one workflow step; times are epoch milliseconds. */
+export const StepRow = Schema.Struct({
+    step: Schema.String,
+    attempt: Schema.Finite,
+    kind: Schema.String,
+    exit: Stored,
+    waitEvent: Schema.NullOr(Schema.String),
+    version: Schema.NullOr(Schema.Finite),
+    dueAtMs: Schema.NullOr(Millis),
+    startedAtMs: Millis,
+    settledAtMs: Schema.NullOr(Millis),
+});
+/** A workflow execution with its status, payload and result sizes in bytes, and steps. */
+export const WorkflowRow = Schema.Struct({
+    ...Identity,
+    executionId: Schema.String,
+    workflow: Schema.String,
+    workflowKey: Schema.String,
+    manifestHash: Schema.String,
+    status: Schema.String,
+    interrupt: Schema.Boolean,
+    caller: Stored,
+    payload: Stored,
+    payloadBytes: Schema.Finite,
+    result: Stored,
+    resultBytes: Schema.NullOr(Schema.Finite),
+    startedAtMs: Millis,
+    finishedAtMs: Schema.NullOr(Millis),
+    steps: Schema.Array(StepRow),
+});
+/**
+ * A command receipt with its outcome, expiry in epoch milliseconds and the
+ * sequences of the events it emitted.
+ */
+export const ReceiptRow = Schema.Struct({
+    commandId: Schema.String,
+    command: Schema.String,
+    callerKey: Stored,
+    outcomeTag: Schema.NullOr(Schema.String),
+    outcome: Stored,
+    expiresAtMs: Millis,
+    events: Schema.Array(Schema.Finite),
+});
+/** A stored event with its sequence, size in bytes and emission time in epoch milliseconds. */
+export const EventRow = Schema.Struct({
+    sequence: Schema.Finite,
+    event: Schema.String,
+    commandId: Schema.NullOr(Schema.String),
+    value: Stored,
+    bytes: Schema.Finite,
+    emittedAtMs: Millis,
+});
+/**
+ * One actor with its state entries, recent rows of every kind, and the totals
+ * they were cut from.
+ */
+export const ActorDetail = Schema.Struct({
+    actor: ActorRow,
+    state: Schema.Array(Schema.Struct({ key: Schema.String, bytes: Schema.Finite, value: Stored })),
+    receipts: Schema.Array(ReceiptRow),
+    events: Schema.Array(EventRow),
+    outbox: Schema.Array(OutboxRow),
+    jobs: Schema.Array(JobRow),
+    deadLetters: Schema.Array(DeadLetterRow),
+    workflows: Schema.Array(WorkflowRow),
+    totals: Schema.Struct({
+        receipts: Schema.Finite,
+        events: Schema.Finite,
+        outbox: Schema.Finite,
+        jobs: Schema.Finite,
+        deadLetters: Schema.Finite,
+        workflows: Schema.Finite,
+    }),
+});
+/** Without `receipts.read`, an operator sees that a command ran but not what it returned. */
+export const OperatorActorDetail = ActorDetail.mapFields((fields) => ({
+    ...fields,
+    receipts: Schema.Array(ReceiptRow.mapFields(({ outcome, ...receipt }) => ({
+        ...receipt,
+        outcome: Schema.optionalKey(outcome),
+    }))),
+}));
+/** A tenant-wide page of outbox rows. */
+export const OutboxPage = Schema.Struct({ outbox: Schema.Array(OutboxRow) });
+/** A tenant-wide page of job rows. */
+export const JobsPage = Schema.Struct({ jobs: Schema.Array(JobRow) });
+/** A tenant-wide page of dead letters; `next` is the dead letter to continue after, or null at the end. */
+export const DeadLettersPage = Schema.Struct({
+    deadLetters: Schema.Array(DeadLetterRow),
+    next: Schema.NullOr(Schema.Struct({ deadAtMs: Millis, jobId: Schema.String })),
+});
+/** A tenant-wide page of workflows; `next` is the execution to continue after, or null at the end. */
+export const WorkflowsPage = Schema.Struct({
+    workflows: Schema.Array(WorkflowRow),
+    next: Schema.NullOr(Schema.Struct({ startedAtMs: Millis, executionId: Schema.String })),
+});
+/** How many of the tenant's actors have one type. */
+export const ActorTypeRow = Schema.Struct({ actorType: Schema.String, actors: Schema.Finite });
+/** A page of actor types by name; `next` is the type to continue after, or null at the end. */
+export const ActorTypesPage = Schema.Struct({
+    actorTypes: Schema.Array(ActorTypeRow),
+    next: Schema.NullOr(Schema.String),
+});
+/** A receipt with the actor that holds it. */
+export const ActorReceiptRow = Schema.Struct({ ...Identity, ...ReceiptRow.fields });
+/**
+ * A page of receipts, the latest expiry first; `next` is the receipt to
+ * continue after, or null at the end.
+ */
+export const ReceiptsPage = Schema.Struct({
+    receipts: Schema.Array(ActorReceiptRow),
+    next: Schema.NullOr(Schema.Struct({ ...Identity, expiresAtMs: Millis, commandId: Schema.String })),
+});
+/** The newest retained event of one name, with its sequence and emission time in epoch milliseconds. */
+export const LatestEventRow = Schema.Struct({
+    event: Schema.String,
+    sequence: Schema.Finite,
+    emittedAtMs: Millis,
+});
+/** A page of an actor's event names; `next` is the name to continue after, or null at the end. */
+export const LatestEventsPage = Schema.Struct({
+    events: Schema.Array(LatestEventRow),
+    next: Schema.NullOr(Schema.String),
+});
+/**
+ * One entry of an actor's timeline: an event at its emission time, or the
+ * command whose turn emitted events, at that turn's emission time and its
+ * first event's sequence. `callerKey` is the caller of the command's retained
+ * receipt, null once the receipt has expired.
+ */
+export const TimelineRow = Schema.Struct({
+    kind: Schema.Literals(["command", "event"]),
+    sequence: Schema.Finite,
+    name: Schema.String,
+    commandId: Schema.String,
+    callerKey: Stored,
+    atMs: Millis,
+});
+/**
+ * A page of an actor's timeline, newest first, each command after the events
+ * its turn emitted; `next` is the entry to continue after, or null at the end.
+ */
+export const TimelinePage = Schema.Struct({
+    entries: Schema.Array(TimelineRow),
+    next: Schema.NullOr(Schema.Struct({ sequence: Schema.Finite, kind: Schema.Literals(["command", "event"]) })),
+});
+/**
+ * The tenant's pending jobs of one name, split by whether an attempt has
+ * failed yet, and its dead letters of that name.
+ */
+export const JobTypeRow = Schema.Struct({
+    job: Schema.String,
+    queued: Schema.Finite,
+    retrying: Schema.Finite,
+    deadLetters: Schema.Finite,
+});
+/** A page of job names; `next` is the name to continue after, or null at the end. */
+export const JobTypesPage = Schema.Struct({
+    jobTypes: Schema.Array(JobTypeRow),
+    next: Schema.NullOr(Schema.String),
+});

package/dist/protocol/wire.d.ts

@@ -0,0 +1,184 @@
+import { Effect, Option, Schema } from "effect";
+import { ActorError, Reason } from "../errors/actor.ts";
+/** The served protocol's major version, sent and checked as `durable-protocol`. */
+export declare const PROTOCOL = 1;
+declare const reasonSchemas: {
+    readonly CommandConflict: Schema.TaggedStruct<"CommandConflict", {
+        readonly _tag: Schema.tag<"CommandConflict">;
+        readonly commandId: Schema.String;
+    }>;
+    readonly CommandExpired: Schema.TaggedStruct<"CommandExpired", {
+        readonly _tag: Schema.tag<"CommandExpired">;
+        readonly commandId: Schema.String;
+    }>;
+    readonly InvalidCommandId: Schema.TaggedStruct<"InvalidCommandId", {
+        readonly commandId: Schema.String;
+        readonly code: Schema.Literals<readonly ["malformed", "future", "window", "version"]>;
+    }>;
+    readonly Unauthorized: Schema.TaggedStruct<"Unauthorized", {
+        readonly _tag: Schema.tag<"Unauthorized">;
+        readonly code: Schema.Literals<readonly ["access_denied", "receipt_access_denied", "reauthorization_unavailable", "missing_credentials", "invalid_credentials", "expired"]>;
+    }>;
+    readonly ActorUnavailable: Schema.TaggedStruct<"ActorUnavailable", {}>;
+    readonly Timeout: Schema.TaggedStruct<"Timeout", {
+        readonly _tag: Schema.tag<"Timeout">;
+        readonly commandId: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly NotCreated: Schema.TaggedStruct<"NotCreated", {}>;
+    readonly MailboxFull: Schema.TaggedStruct<"MailboxFull", {}>;
+    readonly RunnerAtCapacity: Schema.TaggedStruct<"RunnerAtCapacity", {}>;
+    readonly QuotaExceeded: Schema.TaggedStruct<"QuotaExceeded", {
+        readonly _tag: Schema.tag<"QuotaExceeded">;
+        readonly organizationId: Schema.String;
+        readonly period: Schema.String;
+        readonly limitUnits: Schema.Finite;
+        readonly usedUnits: Schema.Finite;
+        readonly requestedUnits: Schema.Finite;
+        readonly unitsPerCommand: Schema.Int;
+        readonly retryAfterMs: Schema.Finite;
+    }>;
+    readonly SpendLimitExceeded: Schema.TaggedStruct<"SpendLimitExceeded", {
+        readonly _tag: Schema.tag<"SpendLimitExceeded">;
+        readonly organizationId: Schema.String;
+        readonly period: Schema.String;
+        readonly limitCents: Schema.Finite;
+        readonly projectedCents: Schema.Finite;
+    }>;
+    readonly ConnectionLimitExceeded: Schema.TaggedStruct<"ConnectionLimitExceeded", {
+        readonly _tag: Schema.tag<"ConnectionLimitExceeded">;
+        readonly organizationId: Schema.String;
+        readonly kind: Schema.Literals<readonly ["socket", "sse"]>;
+        readonly limit: Schema.Finite;
+        readonly open: Schema.Finite;
+    }>;
+    readonly StorageQuotaExceeded: Schema.TaggedStruct<"StorageQuotaExceeded", {
+        readonly _tag: Schema.tag<"StorageQuotaExceeded">;
+        readonly organizationId: Schema.String;
+        readonly deployment: Schema.String;
+        readonly tenant: Schema.String;
+        readonly limitBytes: Schema.Finite;
+        readonly usedBytes: Schema.Finite;
+    }>;
+    readonly InvalidInput: Schema.TaggedStruct<"InvalidInput", {
+        readonly _tag: Schema.tag<"InvalidInput">;
+        readonly code: Schema.Literals<readonly ["decode", "missing_command_id", "too_large", "unsupported_media_type", "unsupported_protocol", "unknown_route", "unservable_id", "origin_not_allowed", "unknown_event", "too_many_filters", "unknown_content", "not_watchable"]>;
+        readonly issues: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly message: Schema.String;
+        }>>>;
+    }>;
+    readonly SessionEnded: Schema.TaggedStruct<"SessionEnded", {
+        readonly _tag: Schema.tag<"SessionEnded">;
+        readonly cause: Schema.Literals<readonly ["ClientClosed", "ServerClosed", "SlowConsumer", "HolderShutdown", "HolderLost", "OwnerLost", "ActivationEnded", "ActorUnavailable", "Defect", "Terminated"]>;
+        readonly resync: Schema.Boolean;
+        readonly retryAfterMs: Schema.optional<Schema.Finite>;
+    }>;
+};
+/** The tag of a reason a served route can answer; `TransportError` is only ever a client's. */
+export type WireTag = keyof typeof reasonSchemas;
+/**
+ * An `ActorError` as a served response carries it: public reason fields plus
+ * the computed getters. `ActorUnavailable` carries no fields because its
+ * `cause` holds internal errors and never crosses the wire.
+ */
+export declare const envelope: (route: {
+    readonly tags: ReadonlyArray<WireTag>;
+    readonly identifier: string;
+}) => Schema.Struct<{
+    readonly _tag: Schema.tag<"ActorError">;
+    readonly reason: Schema.Union<(Schema.TaggedStruct<"ActorUnavailable", {}> | Schema.TaggedStruct<"CommandConflict", {
+        readonly _tag: Schema.tag<"CommandConflict">;
+        readonly commandId: Schema.String;
+    }> | Schema.TaggedStruct<"CommandExpired", {
+        readonly _tag: Schema.tag<"CommandExpired">;
+        readonly commandId: Schema.String;
+    }> | Schema.TaggedStruct<"ConnectionLimitExceeded", {
+        readonly _tag: Schema.tag<"ConnectionLimitExceeded">;
+        readonly organizationId: Schema.String;
+        readonly kind: Schema.Literals<readonly ["socket", "sse"]>;
+        readonly limit: Schema.Finite;
+        readonly open: Schema.Finite;
+    }> | Schema.TaggedStruct<"InvalidCommandId", {
+        readonly commandId: Schema.String;
+        readonly code: Schema.Literals<readonly ["malformed", "future", "window", "version"]>;
+    }> | Schema.TaggedStruct<"InvalidInput", {
+        readonly _tag: Schema.tag<"InvalidInput">;
+        readonly code: Schema.Literals<readonly ["decode", "missing_command_id", "too_large", "unsupported_media_type", "unsupported_protocol", "unknown_route", "unservable_id", "origin_not_allowed", "unknown_event", "too_many_filters", "unknown_content", "not_watchable"]>;
+        readonly issues: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly message: Schema.String;
+        }>>>;
+    }> | Schema.TaggedStruct<"MailboxFull", {}> | Schema.TaggedStruct<"NotCreated", {}> | Schema.TaggedStruct<"QuotaExceeded", {
+        readonly _tag: Schema.tag<"QuotaExceeded">;
+        readonly organizationId: Schema.String;
+        readonly period: Schema.String;
+        readonly limitUnits: Schema.Finite;
+        readonly usedUnits: Schema.Finite;
+        readonly requestedUnits: Schema.Finite;
+        readonly unitsPerCommand: Schema.Int;
+        readonly retryAfterMs: Schema.Finite;
+    }> | Schema.TaggedStruct<"RunnerAtCapacity", {}> | Schema.TaggedStruct<"SessionEnded", {
+        readonly _tag: Schema.tag<"SessionEnded">;
+        readonly cause: Schema.Literals<readonly ["ClientClosed", "ServerClosed", "SlowConsumer", "HolderShutdown", "HolderLost", "OwnerLost", "ActivationEnded", "ActorUnavailable", "Defect", "Terminated"]>;
+        readonly resync: Schema.Boolean;
+        readonly retryAfterMs: Schema.optional<Schema.Finite>;
+    }> | Schema.TaggedStruct<"SpendLimitExceeded", {
+        readonly _tag: Schema.tag<"SpendLimitExceeded">;
+        readonly organizationId: Schema.String;
+        readonly period: Schema.String;
+        readonly limitCents: Schema.Finite;
+        readonly projectedCents: Schema.Finite;
+    }> | Schema.TaggedStruct<"StorageQuotaExceeded", {
+        readonly _tag: Schema.tag<"StorageQuotaExceeded">;
+        readonly organizationId: Schema.String;
+        readonly deployment: Schema.String;
+        readonly tenant: Schema.String;
+        readonly limitBytes: Schema.Finite;
+        readonly usedBytes: Schema.Finite;
+    }> | Schema.TaggedStruct<"Timeout", {
+        readonly _tag: Schema.tag<"Timeout">;
+        readonly commandId: Schema.optionalKey<Schema.String>;
+    }> | Schema.TaggedStruct<"Unauthorized", {
+        readonly _tag: Schema.tag<"Unauthorized">;
+        readonly code: Schema.Literals<readonly ["access_denied", "receipt_access_denied", "reauthorization_unavailable", "missing_credentials", "invalid_credentials", "expired"]>;
+    }>)[]>;
+    readonly isRetryable: Schema.Boolean;
+    readonly retryAfter: Schema.optionalKey<Schema.Finite>;
+}>;
+/** The body of a `500`: a defect reported by trace id only, never its message. */
+export declare const Defect: Schema.Struct<{
+    readonly _tag: Schema.tag<"Defect">;
+    readonly traceId: Schema.String;
+}>;
+/**
+ * The HTTP status a reason is served with. `SessionEnded` maps to `410` but
+ * only connection sessions end this way; no served command or query returns it.
+ */
+export declare const statusOf: (reason: Reason) => number;
+/** The close code a WebSocket session ends with; the `end` message before it is authoritative. */
+export declare const closeCodeOf: (reason: Reason) => number;
+/** The JSON body an `ActorError` is served as, in HTTP bodies and in a session's `end`. */
+export declare const actorErrorBody: (error: ActorError) => Effect.Effect<{
+    readonly _tag: "ActorError";
+    readonly reason: Schema.Json;
+    readonly isRetryable: boolean;
+    readonly retryAfter?: number | undefined;
+}, never, never>;
+/** The `retry-after` header of a delay: whole seconds, rounded up. */
+export declare const retryAfterSeconds: (retryAfterMs: number) => string;
+/**
+ * The `ActorError` a served body carries, or none for any other body. A
+ * reason this client doesn't know is none too, never a guess. The body's
+ * `retryAfter` is the server's already-jittered delay; `headerRetryAfterMs`,
+ * read from `retry-after`, stands in when the body has none.
+ */
+export declare const actorErrorOf: ({ body, headerRetryAfterMs, }: {
+    readonly body: Schema.Json;
+    readonly headerRetryAfterMs: number | undefined;
+}) => Option.Option<ActorError>;
+/** Whether a served body is the opaque `Defect` of a `500`. */
+export declare const isDefectBody: <I>(input: I) => input is I & {
+    readonly _tag: "Defect";
+    readonly traceId: string;
+};
+export {};

package/dist/protocol/wire.js

@@ -0,0 +1,150 @@
+import { Effect, Match, Option, Schema } from "effect";
+import { ActorError, ActorUnavailable, CommandConflict, CommandExpired, ConnectionLimitExceeded, InvalidCommandId, InvalidInput, Reason, QuotaExceeded, SessionEnded, SpendLimitExceeded, StorageQuotaExceeded, Timeout, Unauthorized, withRetryAfter, } from "../errors/actor.js";
+/** The served protocol's major version, sent and checked as `durable-protocol`. */
+export const PROTOCOL = 1;
+const reasonSchemas = {
+    CommandConflict: Schema.TaggedStruct("CommandConflict", CommandConflict.fields),
+    CommandExpired: Schema.TaggedStruct("CommandExpired", CommandExpired.fields),
+    InvalidCommandId: Schema.TaggedStruct("InvalidCommandId", {
+        commandId: InvalidCommandId.fields.commandId,
+        code: InvalidCommandId.fields.code,
+    }),
+    Unauthorized: Schema.TaggedStruct("Unauthorized", Unauthorized.fields),
+    ActorUnavailable: Schema.TaggedStruct("ActorUnavailable", {}),
+    Timeout: Schema.TaggedStruct("Timeout", Timeout.fields),
+    NotCreated: Schema.TaggedStruct("NotCreated", {}),
+    MailboxFull: Schema.TaggedStruct("MailboxFull", {}),
+    RunnerAtCapacity: Schema.TaggedStruct("RunnerAtCapacity", {}),
+    QuotaExceeded: Schema.TaggedStruct("QuotaExceeded", QuotaExceeded.fields),
+    SpendLimitExceeded: Schema.TaggedStruct("SpendLimitExceeded", SpendLimitExceeded.fields),
+    ConnectionLimitExceeded: Schema.TaggedStruct("ConnectionLimitExceeded", ConnectionLimitExceeded.fields),
+    StorageQuotaExceeded: Schema.TaggedStruct("StorageQuotaExceeded", StorageQuotaExceeded.fields),
+    InvalidInput: Schema.TaggedStruct("InvalidInput", InvalidInput.fields),
+    SessionEnded: Schema.TaggedStruct("SessionEnded", SessionEnded.fields),
+};
+/**
+ * An `ActorError` as a served response carries it: public reason fields plus
+ * the computed getters. `ActorUnavailable` carries no fields because its
+ * `cause` holds internal errors and never crosses the wire.
+ */
+export const envelope = (route) => Schema.TaggedStruct("ActorError", {
+    reason: Schema.Union(route.tags.map((tag) => reasonSchemas[tag])),
+    isRetryable: Schema.Boolean,
+    retryAfter: Schema.optionalKey(Schema.Finite),
+}).annotate({ identifier: route.identifier });
+const WireReason = Schema.Union(Object.values(reasonSchemas));
+const encodeReason = Schema.encodeUnknownEffect(Schema.toCodecJson(WireReason));
+/** The body of a `500`: a defect reported by trace id only, never its message. */
+export const Defect = Schema.TaggedStruct("Defect", { traceId: Schema.String }).annotate({
+    identifier: "Defect",
+});
+const inputStatus = (code) => {
+    switch (code) {
+        case "unknown_route":
+        case "unknown_event":
+        case "unknown_content":
+            return 404;
+        case "too_large":
+            return 413;
+        case "unsupported_media_type":
+            return 415;
+        case "origin_not_allowed":
+            return 403;
+        default:
+            return 400;
+    }
+};
+/**
+ * The HTTP status a reason is served with. `SessionEnded` maps to `410` but
+ * only connection sessions end this way; no served command or query returns it.
+ */
+export const statusOf = (reason) => Match.value(reason).pipe(Match.tagsExhaustive({
+    CommandConflict: () => 409,
+    CommandExpired: () => 410,
+    InvalidCommandId: () => 400,
+    Unauthorized: (unauthorized) => (unauthorized.isCredential ? 401 : 403),
+    ActorUnavailable: () => 503,
+    RunnerAtCapacity: () => 503,
+    QuotaExceeded: () => 429,
+    SpendLimitExceeded: () => 402,
+    ConnectionLimitExceeded: () => 429,
+    StorageQuotaExceeded: () => 429,
+    Timeout: () => 504,
+    NotCreated: () => 404,
+    MailboxFull: () => 429,
+    InvalidInput: (input) => inputStatus(input.code),
+    TransportError: () => 502,
+    SessionEnded: () => 410,
+}));
+/** The close code a WebSocket session ends with; the `end` message before it is authoritative. */
+export const closeCodeOf = (reason) => Match.value(reason).pipe(Match.tagsExhaustive({
+    ActorUnavailable: () => 1013,
+    RunnerAtCapacity: () => 1013,
+    QuotaExceeded: () => 1008,
+    SpendLimitExceeded: () => 1008,
+    ConnectionLimitExceeded: () => 1008,
+    StorageQuotaExceeded: () => 1008,
+    NotCreated: () => 4404,
+    Unauthorized: (unauthorized) => unauthorized.code === "reauthorization_unavailable" ? 1013 : 1008,
+    InvalidInput: () => 4400,
+    SessionEnded: (session) => {
+        switch (session.cause) {
+            case "ClientClosed":
+            case "ServerClosed":
+            case "Terminated":
+                return 1000;
+            case "HolderShutdown":
+                return 1012;
+            case "Defect":
+                return 1011;
+            default:
+                return 1013;
+        }
+    },
+    CommandConflict: () => 1011,
+    CommandExpired: () => 1011,
+    InvalidCommandId: () => 1011,
+    Timeout: () => 1011,
+    MailboxFull: () => 1011,
+    TransportError: () => 1011,
+}));
+const ActorErrorBody = Schema.TaggedStruct("ActorError", {
+    reason: Schema.Json,
+    isRetryable: Schema.Boolean,
+    retryAfter: Schema.optionalKey(Schema.Finite),
+});
+/** The JSON body an `ActorError` is served as, in HTTP bodies and in a session's `end`. */
+export const actorErrorBody = Effect.fnUntraced(function* (error) {
+    const reason = yield* encodeReason(error.reason).pipe(Effect.orDie);
+    return Option.match(error.retryAfter, {
+        onNone: () => ActorErrorBody.make({ reason, isRetryable: error.isRetryable }),
+        onSome: (retryAfter) => ActorErrorBody.make({ reason, isRetryable: error.isRetryable, retryAfter }),
+    });
+});
+/** The `retry-after` header of a delay: whole seconds, rounded up. */
+export const retryAfterSeconds = (retryAfterMs) => String(Math.ceil(retryAfterMs / 1000));
+const Envelope = Schema.TaggedStruct("ActorError", {
+    reason: Schema.Struct({ _tag: Schema.String }),
+    retryAfter: Schema.optionalKey(Schema.Finite),
+});
+const isEnvelope = Schema.is(Envelope);
+const decodeReason = Schema.decodeUnknownOption(Schema.toCodecJson(Reason));
+const isUnavailable = Schema.is(reasonSchemas.ActorUnavailable);
+/**
+ * The `ActorError` a served body carries, or none for any other body. A
+ * reason this client doesn't know is none too, never a guess. The body's
+ * `retryAfter` is the server's already-jittered delay; `headerRetryAfterMs`,
+ * read from `retry-after`, stands in when the body has none.
+ */
+export const actorErrorOf = ({ body, headerRetryAfterMs, }) => Option.flatMap(Option.liftPredicate(body, isEnvelope), (envelope) => {
+    const reason = isUnavailable(envelope.reason)
+        ? Option.some(ActorUnavailable.make({ cause: undefined }))
+        : decodeReason(envelope.reason);
+    return Option.map(reason, (value) => {
+        const error = ActorError.make({ reason: value });
+        const retryAfter = envelope.retryAfter ?? headerRetryAfterMs;
+        return retryAfter === undefined ? error : withRetryAfter(retryAfter)(error);
+    });
+});
+/** Whether a served body is the opaque `Defect` of a `500`. */
+export const isDefectBody = Schema.is(Defect);