@rikalabs/akter 0.1.0-alpha.0

package/dist/errors/actor.d.ts

@@ -0,0 +1,200 @@
+import { Option, Schema } from "effect";
+declare const CommandConflict_base: Schema.Class<CommandConflict, Schema.TaggedStruct<"CommandConflict", {
+    readonly commandId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A retry reused a command id with a different command or payload, so nothing ran. */
+export declare class CommandConflict extends CommandConflict_base {
+}
+declare const CommandExpired_base: Schema.Class<CommandExpired, Schema.TaggedStruct<"CommandExpired", {
+    readonly commandId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The command id passed its expiry and no receipt remains to replay, so the
+ * command is not run. It says nothing about whether an earlier attempt
+ * committed; retry only with a new operation, never a new id for the same one.
+ */
+export declare class CommandExpired extends CommandExpired_base {
+}
+declare const InvalidCommandId_base: Schema.Class<InvalidCommandId, Schema.TaggedStruct<"InvalidCommandId", {
+    readonly commandId: Schema.String;
+    readonly code: Schema.Literals<readonly ["malformed", "future", "window", "version"]>;
+    readonly neverAdmitted: Schema.optionalKey<Schema.Boolean>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * `malformed`: not a v1 id. `future`: issued after the database clock; the
+ * same id is admissible once the clock passes it. `window`: its lifetime is
+ * not the deployment's retry window. `version`: a protocol version this
+ * runner doesn't serve. `neverAdmitted`, set only by a client, is true when
+ * that client minted the id and every attempt it sent was refused before any
+ * turn, so no attempt can have committed.
+ */
+export declare class InvalidCommandId extends InvalidCommandId_base {
+}
+declare const Unauthorized_base: Schema.Class<Unauthorized, Schema.TaggedStruct<"Unauthorized", {
+    readonly code: Schema.Literals<readonly ["access_denied", "receipt_access_denied", "reauthorization_unavailable", "missing_credentials", "invalid_credentials", "expired"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * `missing_credentials`, `invalid_credentials`, and `expired` come from a
+ * served endpoint's auth provider; `access_denied` and `receipt_access_denied`
+ * from an actor's `access` policy or the runtime's `authorize` hook.
+ */
+export declare class Unauthorized extends Unauthorized_base {
+    /**
+     * Whether the credential failed rather than the caller's permission: a
+     * served `401` with a `Bearer` challenge, refused before any turn ran, which
+     * a fresh credential can resolve. Every other code is a `403` decision.
+     */
+    get isCredential(): boolean;
+}
+declare const InvalidInput_base: Schema.Class<InvalidInput, Schema.TaggedStruct<"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;
+    }>>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A served request the boundary refused before any turn. Never in a typed
+ * in-process handle's error channel. A served watch ends with `not_watchable`
+ * when a rerun reads something no commit signal covers, such as its placement
+ * group, and a watch request for a query not declared `watch: true` is refused
+ * with it; an in-process watch dies with it instead.
+ */
+export declare class InvalidInput extends InvalidInput_base {
+}
+declare const TransportError_base: Schema.Class<TransportError, Schema.TaggedStruct<"TransportError", {
+    readonly code: Schema.Literals<readonly ["network", "status", "decode", "defect"]>;
+    readonly status: Schema.optionalKey<Schema.Int>;
+    readonly retryable: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Produced only by clients, for a response that is neither a success, a
+ * declared failure, nor an `ActorError` envelope. `retryable` says whether a
+ * retry with the same command id is safe.
+ */
+export declare class TransportError extends TransportError_base {
+}
+declare const ActorUnavailable_base: Schema.Class<ActorUnavailable, Schema.TaggedStruct<"ActorUnavailable", {
+    readonly cause: Schema.Defect;
+    /** Preserved across runner RPCs so a pre-turn refusal is not retried inside the receiving runtime. */
+    readonly overloaded: Schema.optionalKey<Schema.Boolean>;
+}>, import("effect/Cause").YieldableError>;
+/** The runtime could not run the command now, for example an unreachable owner or database; `cause` says why. Retry with the same command id. */
+export declare class ActorUnavailable extends ActorUnavailable_base {
+}
+declare const Timeout_base: Schema.Class<Timeout, Schema.TaggedStruct<"Timeout", {
+    readonly commandId: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** The caller stopped waiting for a reply (`deliveryTimeout`, or `commandTimeout` for a query). The turn is not cancelled and may still commit, so retry with the same command id. */
+export declare class Timeout extends Timeout_base {
+}
+declare const NotCreated_base: Schema.Class<NotCreated, Schema.TaggedStruct<"NotCreated", {}>, import("effect/Cause").YieldableError>;
+/** A command other than `policy.createdBy` reached an actor that does not exist yet; its handler did not run and no receipt was written. */
+export declare class NotCreated extends NotCreated_base {
+}
+declare const MailboxFull_base: Schema.Class<MailboxFull, Schema.TaggedStruct<"MailboxFull", {}>, import("effect/Cause").YieldableError>;
+/** The activation's mailbox holds `policy.mailboxCapacity` commands, so the command was not admitted. */
+export declare class MailboxFull extends MailboxFull_base {
+}
+declare const RunnerAtCapacity_base: Schema.Class<RunnerAtCapacity, Schema.TaggedStruct<"RunnerAtCapacity", {}>, import("effect/Cause").YieldableError>;
+/**
+ * The runner already holds its `maxResidentActors` activations and cannot
+ * start another, so the command was not admitted. It says nothing about an
+ * earlier attempt with the same command id, which may have committed.
+ */
+export declare class RunnerAtCapacity extends RunnerAtCapacity_base {
+}
+declare const QuotaExceeded_base: Schema.Class<QuotaExceeded, Schema.TaggedStruct<"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;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The hosted organization's period usage would exceed its plan's hard quota.
+ * `limitUnits`, `usedUnits` and `requestedUnits` are usage units, where one
+ * command weighs `unitsPerCommand`, so a reader states them as commands
+ * without knowing the weights.
+ */
+export declare class QuotaExceeded extends QuotaExceeded_base {
+}
+declare const SpendLimitExceeded_base: Schema.Class<SpendLimitExceeded, Schema.TaggedStruct<"SpendLimitExceeded", {
+    readonly organizationId: Schema.String;
+    readonly period: Schema.String;
+    readonly limitCents: Schema.Finite;
+    readonly projectedCents: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** The hosted organization's estimated period cost would exceed its spend limit. */
+export declare class SpendLimitExceeded extends SpendLimitExceeded_base {
+}
+declare const ConnectionLimitExceeded_base: Schema.Class<ConnectionLimitExceeded, Schema.TaggedStruct<"ConnectionLimitExceeded", {
+    readonly organizationId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["socket", "sse"]>;
+    readonly limit: Schema.Finite;
+    readonly open: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** The hosted organization already holds its plan's allowed concurrent connections. */
+export declare class ConnectionLimitExceeded extends ConnectionLimitExceeded_base {
+}
+declare const StorageQuotaExceeded_base: Schema.Class<StorageQuotaExceeded, Schema.TaggedStruct<"StorageQuotaExceeded", {
+    readonly organizationId: Schema.String;
+    readonly deployment: Schema.String;
+    readonly tenant: Schema.String;
+    readonly limitBytes: Schema.Finite;
+    readonly usedBytes: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A Free tenant's latest storage sample is at or over its plan's included
+ * bytes. Waiting for the next period does not lift it; the tenant must hold
+ * less data before new commands are admitted, so it carries no retry time.
+ */
+export declare class StorageQuotaExceeded extends StorageQuotaExceeded_base {
+}
+declare const SessionEnded_base: Schema.Class<SessionEnded, Schema.TaggedStruct<"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>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A connection or stream ended. `resync` tells the client that frames may have
+ * been lost, so it must replay events from its cursor after reconnecting.
+ */
+export declare class SessionEnded extends SessionEnded_base {
+    get isRetryable(): boolean;
+}
+/** Every reason an `ActorError` carries. */
+export declare const Reason: Schema.Union<readonly [typeof CommandConflict, typeof CommandExpired, typeof InvalidCommandId, typeof Unauthorized, typeof ActorUnavailable, typeof Timeout, typeof NotCreated, typeof MailboxFull, typeof RunnerAtCapacity, typeof QuotaExceeded, typeof SpendLimitExceeded, typeof ConnectionLimitExceeded, typeof StorageQuotaExceeded, typeof SessionEnded, typeof InvalidInput, typeof TransportError]>;
+/** One `Reason` value. */
+export type Reason = typeof Reason.Type;
+declare const ActorError_base: Schema.Class<ActorError, Schema.TaggedStruct<"ActorError", {
+    readonly reason: Schema.Union<readonly [typeof CommandConflict, typeof CommandExpired, typeof InvalidCommandId, typeof Unauthorized, typeof ActorUnavailable, typeof Timeout, typeof NotCreated, typeof MailboxFull, typeof RunnerAtCapacity, typeof QuotaExceeded, typeof SpendLimitExceeded, typeof ConnectionLimitExceeded, typeof StorageQuotaExceeded, typeof SessionEnded, typeof InvalidInput, typeof TransportError]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The runtime's own failure for a call: `reason` says which. Declared command
+ * errors are never wrapped in it. `isRetryable` and `retryAfter` say whether
+ * and when a retry with the same command id is safe.
+ */
+export declare class ActorError extends ActorError_base {
+    get isRetryable(): boolean;
+    /**
+     * Milliseconds to wait before retrying with the same command id: 250 for
+     * `ActorUnavailable`, 1,000 for `RunnerAtCapacity`, and 100 for
+     * `MailboxFull`, each with ±50% jitter drawn once per error.
+     */
+    get retryAfter(): Option.Option<number>;
+    get message(): string;
+}
+/** Fixes `retryAfter` to a server's already-jittered value, as a client rebuilds a served envelope. */
+export declare const withRetryAfter: (retryAfterMs: number) => (error: ActorError) => ActorError;
+export declare namespace ActorError {
+    /** An `ActorError` whose reason is one of `Reasons`, for handle signatures that name what can occur. */
+    type Of<Reasons extends Reason["_tag"]> = [Reasons] extends [never] ? never : ActorError & {
+        readonly reason: Extract<Reason, {
+            readonly _tag: Reasons;
+        }>;
+    };
+}
+export {};

package/dist/errors/actor.js

@@ -0,0 +1,271 @@
+import { Effect, Option, Random, Schema } from "effect";
+/** A retry reused a command id with a different command or payload, so nothing ran. */
+export class CommandConflict extends Schema.TaggedError()("CommandConflict", {
+    commandId: Schema.String,
+}) {
+}
+/**
+ * The command id passed its expiry and no receipt remains to replay, so the
+ * command is not run. It says nothing about whether an earlier attempt
+ * committed; retry only with a new operation, never a new id for the same one.
+ */
+export class CommandExpired extends Schema.TaggedError()("CommandExpired", {
+    commandId: Schema.String,
+}) {
+}
+/**
+ * `malformed`: not a v1 id. `future`: issued after the database clock; the
+ * same id is admissible once the clock passes it. `window`: its lifetime is
+ * not the deployment's retry window. `version`: a protocol version this
+ * runner doesn't serve. `neverAdmitted`, set only by a client, is true when
+ * that client minted the id and every attempt it sent was refused before any
+ * turn, so no attempt can have committed.
+ */
+export class InvalidCommandId extends Schema.TaggedError()("InvalidCommandId", {
+    commandId: Schema.String,
+    code: Schema.Literals(["malformed", "future", "window", "version"]),
+    neverAdmitted: Schema.optionalKey(Schema.Boolean),
+}) {
+}
+const CREDENTIAL_CODES = new Set([
+    "missing_credentials",
+    "invalid_credentials",
+    "expired",
+]);
+/**
+ * `missing_credentials`, `invalid_credentials`, and `expired` come from a
+ * served endpoint's auth provider; `access_denied` and `receipt_access_denied`
+ * from an actor's `access` policy or the runtime's `authorize` hook.
+ */
+export class Unauthorized extends Schema.TaggedError()("Unauthorized", {
+    code: Schema.Literals([
+        "access_denied",
+        "receipt_access_denied",
+        "reauthorization_unavailable",
+        "missing_credentials",
+        "invalid_credentials",
+        "expired",
+    ]),
+}) {
+    /**
+     * Whether the credential failed rather than the caller's permission: a
+     * served `401` with a `Bearer` challenge, refused before any turn ran, which
+     * a fresh credential can resolve. Every other code is a `403` decision.
+     */
+    get isCredential() {
+        return CREDENTIAL_CODES.has(this.code);
+    }
+}
+/** A schema issue at a path, without the offending value. */
+const InputIssue = Schema.Struct({ path: Schema.String, message: Schema.String });
+/**
+ * A served request the boundary refused before any turn. Never in a typed
+ * in-process handle's error channel. A served watch ends with `not_watchable`
+ * when a rerun reads something no commit signal covers, such as its placement
+ * group, and a watch request for a query not declared `watch: true` is refused
+ * with it; an in-process watch dies with it instead.
+ */
+export class InvalidInput extends Schema.TaggedError()("InvalidInput", {
+    code: Schema.Literals([
+        "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",
+    ]),
+    issues: Schema.optionalKey(Schema.Array(InputIssue)),
+}) {
+}
+/**
+ * Produced only by clients, for a response that is neither a success, a
+ * declared failure, nor an `ActorError` envelope. `retryable` says whether a
+ * retry with the same command id is safe.
+ */
+export class TransportError extends Schema.TaggedError()("TransportError", {
+    code: Schema.Literals(["network", "status", "decode", "defect"]),
+    status: Schema.optionalKey(Schema.Int),
+    retryable: Schema.Boolean,
+}) {
+}
+/** The runtime could not run the command now, for example an unreachable owner or database; `cause` says why. Retry with the same command id. */
+export class ActorUnavailable extends Schema.TaggedError()("ActorUnavailable", {
+    cause: Schema.Defect(),
+    /** Preserved across runner RPCs so a pre-turn refusal is not retried inside the receiving runtime. */
+    overloaded: Schema.optionalKey(Schema.Boolean),
+}) {
+}
+/** The caller stopped waiting for a reply (`deliveryTimeout`, or `commandTimeout` for a query). The turn is not cancelled and may still commit, so retry with the same command id. */
+export class Timeout extends Schema.TaggedError()("Timeout", {
+    commandId: Schema.optionalKey(Schema.String),
+}) {
+}
+/** A command other than `policy.createdBy` reached an actor that does not exist yet; its handler did not run and no receipt was written. */
+export class NotCreated extends Schema.TaggedError()("NotCreated", {}) {
+}
+/** The activation's mailbox holds `policy.mailboxCapacity` commands, so the command was not admitted. */
+export class MailboxFull extends Schema.TaggedError()("MailboxFull", {}) {
+}
+/**
+ * The runner already holds its `maxResidentActors` activations and cannot
+ * start another, so the command was not admitted. It says nothing about an
+ * earlier attempt with the same command id, which may have committed.
+ */
+export class RunnerAtCapacity extends Schema.TaggedError()("RunnerAtCapacity", {}) {
+}
+/**
+ * The hosted organization's period usage would exceed its plan's hard quota.
+ * `limitUnits`, `usedUnits` and `requestedUnits` are usage units, where one
+ * command weighs `unitsPerCommand`, so a reader states them as commands
+ * without knowing the weights.
+ */
+export class QuotaExceeded extends Schema.TaggedError()("QuotaExceeded", {
+    organizationId: Schema.String,
+    period: Schema.String,
+    limitUnits: Schema.Finite,
+    usedUnits: Schema.Finite,
+    requestedUnits: Schema.Finite,
+    unitsPerCommand: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+    retryAfterMs: Schema.Finite,
+}) {
+}
+/** The hosted organization's estimated period cost would exceed its spend limit. */
+export class SpendLimitExceeded extends Schema.TaggedError()("SpendLimitExceeded", {
+    organizationId: Schema.String,
+    period: Schema.String,
+    limitCents: Schema.Finite,
+    projectedCents: Schema.Finite,
+}) {
+}
+/** The hosted organization already holds its plan's allowed concurrent connections. */
+export class ConnectionLimitExceeded extends Schema.TaggedError()("ConnectionLimitExceeded", {
+    organizationId: Schema.String,
+    kind: Schema.Literals(["socket", "sse"]),
+    limit: Schema.Finite,
+    open: Schema.Finite,
+}) {
+}
+/**
+ * A Free tenant's latest storage sample is at or over its plan's included
+ * bytes. Waiting for the next period does not lift it; the tenant must hold
+ * less data before new commands are admitted, so it carries no retry time.
+ */
+export class StorageQuotaExceeded extends Schema.TaggedError()("StorageQuotaExceeded", {
+    organizationId: Schema.String,
+    deployment: Schema.String,
+    tenant: Schema.String,
+    limitBytes: Schema.Finite,
+    usedBytes: Schema.Finite,
+}) {
+}
+const RETRYABLE_SESSION_ENDS = new Set([
+    "SlowConsumer",
+    "HolderShutdown",
+    "HolderLost",
+    "OwnerLost",
+    "ActivationEnded",
+    "ActorUnavailable",
+]);
+/**
+ * A connection or stream ended. `resync` tells the client that frames may have
+ * been lost, so it must replay events from its cursor after reconnecting.
+ */
+export class SessionEnded extends Schema.TaggedError()("SessionEnded", {
+    cause: Schema.Literals([
+        "ClientClosed",
+        "ServerClosed",
+        "SlowConsumer",
+        "HolderShutdown",
+        "HolderLost",
+        "OwnerLost",
+        "ActivationEnded",
+        "ActorUnavailable",
+        "Defect",
+        "Terminated",
+    ]),
+    resync: Schema.Boolean,
+    retryAfterMs: Schema.optional(Schema.Finite),
+}) {
+    get isRetryable() {
+        return RETRYABLE_SESSION_ENDS.has(this.cause);
+    }
+}
+/** Every reason an `ActorError` carries. */
+export const Reason = Schema.Union([
+    CommandConflict,
+    CommandExpired,
+    InvalidCommandId,
+    Unauthorized,
+    ActorUnavailable,
+    Timeout,
+    NotCreated,
+    MailboxFull,
+    RunnerAtCapacity,
+    QuotaExceeded,
+    SpendLimitExceeded,
+    ConnectionLimitExceeded,
+    StorageQuotaExceeded,
+    SessionEnded,
+    InvalidInput,
+    TransportError,
+]);
+/**
+ * The runtime's own failure for a call: `reason` says which. Declared command
+ * errors are never wrapped in it. `isRetryable` and `retryAfter` say whether
+ * and when a retry with the same command id is safe.
+ */
+export class ActorError extends Schema.TaggedError()("ActorError", { reason: Reason }) {
+    get isRetryable() {
+        if (Schema.is(SessionEnded)(this.reason))
+            return this.reason.isRetryable;
+        if (Schema.is(Unauthorized)(this.reason))
+            return this.reason.code === "reauthorization_unavailable";
+        if (isTransportError(this.reason))
+            return this.reason.retryable;
+        return isRetryableReason(this.reason);
+    }
+    /**
+     * Milliseconds to wait before retrying with the same command id: 250 for
+     * `ActorUnavailable`, 1,000 for `RunnerAtCapacity`, and 100 for
+     * `MailboxFull`, each with ±50% jitter drawn once per error.
+     */
+    get retryAfter() {
+        if (Schema.is(QuotaExceeded)(this.reason))
+            return Option.some(this.reason.retryAfterMs);
+        if (Schema.is(SessionEnded)(this.reason))
+            return Option.fromUndefinedOr(this.reason.retryAfterMs);
+        const nominal = NOMINAL_RETRY_AFTER[this.reason._tag];
+        if (nominal === undefined)
+            return Option.none();
+        let value = jittered.get(this);
+        if (value === undefined) {
+            value = Math.round(nominal * Effect.runSync(Random.nextBetween(0.5, 1.5)));
+            jittered.set(this, value);
+        }
+        return Option.some(value);
+    }
+    get message() {
+        return this.reason.message;
+    }
+}
+const isTransportError = Schema.is(TransportError);
+const isRetryableReason = Schema.is(Schema.Union([ActorUnavailable, Timeout, MailboxFull, RunnerAtCapacity, ConnectionLimitExceeded]));
+const NOMINAL_RETRY_AFTER = {
+    ActorUnavailable: 250,
+    RunnerAtCapacity: 1_000,
+    MailboxFull: 100,
+    ConnectionLimitExceeded: 1_000,
+};
+const jittered = new WeakMap();
+/** Fixes `retryAfter` to a server's already-jittered value, as a client rebuilds a served envelope. */
+export const withRetryAfter = (retryAfterMs) => (error) => {
+    if (NOMINAL_RETRY_AFTER[error.reason._tag] !== undefined)
+        jittered.set(error, retryAfterMs);
+    return error;
+};

package/dist/errors/content.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from "effect";
+declare const InvalidContentRef_base: Schema.Class<InvalidContentRef, Schema.TaggedStruct<"InvalidContentRef", {
+    readonly reason: Schema.Literals<readonly ["malformed", "invalid", "expired"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * `attach` refused a content reference: its grant is malformed, was not
+ * issued by this deployment for this tenant and content, or leaves less
+ * than the skew margin before it expires. A reference from a client is input,
+ * so a command declares or handles this like any other application failure.
+ */
+export declare class InvalidContentRef extends InvalidContentRef_base {
+}
+declare const ContentTooLarge_base: Schema.Class<ContentTooLarge, Schema.TaggedStruct<"ContentTooLarge", {
+    readonly maxBytes: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** An upload passed the content size limit; nothing of it was stored. */
+export declare class ContentTooLarge extends ContentTooLarge_base {
+}
+export {};

package/dist/errors/content.js

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+/**
+ * `attach` refused a content reference: its grant is malformed, was not
+ * issued by this deployment for this tenant and content, or leaves less
+ * than the skew margin before it expires. A reference from a client is input,
+ * so a command declares or handles this like any other application failure.
+ */
+export class InvalidContentRef extends Schema.TaggedError()("InvalidContentRef", { reason: Schema.Literals(["malformed", "invalid", "expired"]) }) {
+}
+/** An upload passed the content size limit; nothing of it was stored. */
+export class ContentTooLarge extends Schema.TaggedError()("ContentTooLarge", {
+    maxBytes: Schema.Int,
+}) {
+}

package/dist/errors/database.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from "effect";
+declare const DataDirLocked_base: Schema.Class<DataDirLocked, Schema.TaggedStruct<"DataDirLocked", {
+    readonly dataDir: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Another process, or another open layer in this one, holds the data directory's lock. */
+export declare class DataDirLocked extends DataDirLocked_base {
+    get message(): string;
+}
+declare const DataDirVersion_base: Schema.Class<DataDirVersion, Schema.TaggedStruct<"DataDirVersion", {
+    readonly dataDir: Schema.String;
+    readonly found: Schema.String;
+    readonly expected: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The data directory was written by another Postgres major than the pinned
+ * PGlite embeds, which Postgres cannot open. Dump it with the core release
+ * that wrote it and load the dump into a new directory.
+ */
+export declare class DataDirVersion extends DataDirVersion_base {
+    get message(): string;
+}
+export {};

package/dist/errors/database.js

@@ -0,0 +1,23 @@
+import { Schema } from "effect";
+/** Another process, or another open layer in this one, holds the data directory's lock. */
+export class DataDirLocked extends Schema.TaggedError()("DataDirLocked", {
+    dataDir: Schema.String,
+}) {
+    get message() {
+        return `PGlite data directory ${this.dataDir} is in use by another process; one process may open it at a time`;
+    }
+}
+/**
+ * The data directory was written by another Postgres major than the pinned
+ * PGlite embeds, which Postgres cannot open. Dump it with the core release
+ * that wrote it and load the dump into a new directory.
+ */
+export class DataDirVersion extends Schema.TaggedError()("DataDirVersion", {
+    dataDir: Schema.String,
+    found: Schema.String,
+    expected: Schema.String,
+}) {
+    get message() {
+        return `PGlite data directory ${this.dataDir} is Postgres ${this.found}, but this release embeds Postgres ${this.expected}; dump it with the release that wrote it and load the dump into a new directory`;
+    }
+}

package/dist/errors/events.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+declare const UnknownCursor_base: Schema.Class<UnknownCursor, Schema.TaggedStruct<"UnknownCursor", {
+    readonly cursor: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The cursor is malformed or ahead of every event this actor has committed. */
+export declare class UnknownCursor extends UnknownCursor_base {
+}
+declare const RetentionGap_base: Schema.Class<RetentionGap, Schema.TaggedStruct<"RetentionGap", {
+    readonly cursor: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Events after the cursor were pruned, so replay cannot be continuous; the
+ * reader must resynchronize from state instead of resuming.
+ */
+export declare class RetentionGap extends RetentionGap_base {
+}
+export {};

package/dist/errors/events.js

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+/** The cursor is malformed or ahead of every event this actor has committed. */
+export class UnknownCursor extends Schema.TaggedError()("UnknownCursor", {
+    cursor: Schema.String,
+}) {
+}
+/**
+ * Events after the cursor were pruned, so replay cannot be continuous; the
+ * reader must resynchronize from state instead of resuming.
+ */
+export class RetentionGap extends Schema.TaggedError()("RetentionGap", {
+    cursor: Schema.String,
+}) {
+}

package/dist/errors/subscription.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+declare const SubscriptionFailure_base: Schema.Class<SubscriptionFailure, Schema.TaggedStruct<"SubscriptionFailure", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Why the relay could not deliver or register a subscription: a route that
+ * failed, a source with no recorded placement, or a declaration this runner
+ * lacks. It backs the row off with `last_error` rather than skipping it.
+ */
+export declare class SubscriptionFailure extends SubscriptionFailure_base {
+}
+export {};

package/dist/errors/subscription.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+/**
+ * Why the relay could not deliver or register a subscription: a route that
+ * failed, a source with no recorded placement, or a declaration this runner
+ * lacks. It backs the row off with `last_error` rather than skipping it.
+ */
+export class SubscriptionFailure extends Schema.TaggedError()("SubscriptionFailure", { message: Schema.String }) {
+}

package/dist/errors/workflow.d.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+declare const InvalidExecutionId_base: Schema.Class<InvalidExecutionId, Schema.TaggedStruct<"InvalidExecutionId", {
+    readonly executionId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The execution id is not a `w1.` id, is malformed, or names another tenant,
+ * actor, or workflow member than the one it is used with.
+ */
+export declare class InvalidExecutionId extends InvalidExecutionId_base {
+}
+declare const InvalidExecutionKey_base: Schema.Class<InvalidExecutionKey, Schema.TaggedStruct<"InvalidExecutionKey", {
+    readonly bytes: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** A workflow key is empty or longer than 256 UTF-8 bytes. */
+export declare class InvalidExecutionKey extends InvalidExecutionKey_base {
+}
+declare const ActivityOutcomeUnknown_base: Schema.Class<ActivityOutcomeUnknown, Schema.TaggedStruct<"ActivityOutcomeUnknown", {
+    readonly executionId: Schema.String;
+    readonly step: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An activity's actor call would be sent past its derived command id's expiry
+ * bound, where the receiver's receipt may be pruned; the call is not sent and
+ * its outcome is unknown.
+ */
+export declare class ActivityOutcomeUnknown extends ActivityOutcomeUnknown_base {
+}
+export {};

package/dist/errors/workflow.js

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+/**
+ * The execution id is not a `w1.` id, is malformed, or names another tenant,
+ * actor, or workflow member than the one it is used with.
+ */
+export class InvalidExecutionId extends Schema.TaggedError()("InvalidExecutionId", { executionId: Schema.String }) {
+}
+/** A workflow key is empty or longer than 256 UTF-8 bytes. */
+export class InvalidExecutionKey extends Schema.TaggedError()("InvalidExecutionKey", { bytes: Schema.Int }) {
+}
+/**
+ * An activity's actor call would be sent past its derived command id's expiry
+ * bound, where the receiver's receipt may be pruned; the call is not sent and
+ * its outcome is unknown.
+ */
+export class ActivityOutcomeUnknown extends Schema.TaggedError()("ActivityOutcomeUnknown", { executionId: Schema.String, step: Schema.String }) {
+}