@rikalabs/akter 0.1.0-alpha.1 → 0.1.0-alpha.4

package/dist/protocol/inspection.d.ts

@@ -40,6 +40,24 @@ export declare const ActorRow: Schema.Struct<{
     readonly lastEventSequence: Schema.Finite;
 }>;
 export type ActorRow = typeof ActorRow.Type;
+/**
+ * An actor as a list shows it, with its last command: the command and commit
+ * time of its receipt with the newest recorded commit time among its 256
+ * greatest command ids, null when none of them records one.
+ */
+export declare const ActorListRow: Schema.Struct<{
+    readonly actorType: Schema.String;
+    readonly actorId: Schema.String;
+    readonly placement: Schema.NullOr<Schema.String>;
+    readonly generation: Schema.Finite;
+    readonly created: Schema.Boolean;
+    readonly lastEventSequence: Schema.Finite;
+    readonly lastCommand: Schema.NullOr<Schema.Struct<{
+        readonly command: Schema.String;
+        readonly committedAtMs: Schema.Finite;
+    }>>;
+}>;
+export type ActorListRow = typeof ActorListRow.Type;
 /** A page of actors; `next` is the identity to continue from, or null at the end. */
 export declare const ActorsPage: Schema.Struct<{
     readonly actors: Schema.$Array<Schema.Struct<{
@@ -49,6 +67,10 @@ export declare const ActorsPage: Schema.Struct<{
         readonly generation: Schema.Finite;
         readonly created: Schema.Boolean;
         readonly lastEventSequence: Schema.Finite;
+        readonly lastCommand: Schema.NullOr<Schema.Struct<{
+            readonly command: Schema.String;
+            readonly committedAtMs: Schema.Finite;
+        }>>;
     }>>;
     readonly next: Schema.NullOr<Schema.Struct<{
         actorType: Schema.String;
@@ -186,7 +208,10 @@ export declare const WorkflowRow: Schema.Struct<{
 export type WorkflowRow = typeof WorkflowRow.Type;
 /**
  * A command receipt with its outcome, expiry in epoch milliseconds and the
- * sequences of the events it emitted.
+ * sequences of the events it emitted. `startedAtMs` is the database clock its
+ * batch's fenced read selected and `committedAtMs` the database clock when
+ * its commit wrote it; both are null on a receipt written before the runtime
+ * recorded them.
  */
 export declare const ReceiptRow: Schema.Struct<{
     readonly commandId: Schema.String;
@@ -203,6 +228,8 @@ export declare const ReceiptRow: Schema.Struct<{
         readonly undecodable: Schema.String;
     }>]>>;
     readonly expiresAtMs: Schema.Finite;
+    readonly startedAtMs: Schema.NullOr<Schema.Finite>;
+    readonly committedAtMs: Schema.NullOr<Schema.Finite>;
     readonly events: Schema.$Array<Schema.Finite>;
 }>;
 export type ReceiptRow = typeof ReceiptRow.Type;
@@ -257,6 +284,8 @@ export declare const ActorDetail: Schema.Struct<{
             readonly undecodable: Schema.String;
         }>]>>;
         readonly expiresAtMs: Schema.Finite;
+        readonly startedAtMs: Schema.NullOr<Schema.Finite>;
+        readonly committedAtMs: Schema.NullOr<Schema.Finite>;
         readonly events: Schema.$Array<Schema.Finite>;
     }>>;
     readonly events: Schema.$Array<Schema.Struct<{
@@ -532,6 +561,8 @@ export declare const OperatorActorDetail: Schema.Struct<{
         }>]>>;
         readonly outcomeTag: Schema.NullOr<Schema.String>;
         readonly expiresAtMs: Schema.Finite;
+        readonly startedAtMs: Schema.NullOr<Schema.Finite>;
+        readonly committedAtMs: Schema.NullOr<Schema.Finite>;
         readonly events: Schema.$Array<Schema.Finite>;
         readonly outcome: Schema.optionalKey<Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
             readonly json: Schema.Codec<Schema.Json, Schema.Json, never, never>;
@@ -693,6 +724,8 @@ export declare const ActorReceiptRow: Schema.Struct<{
         readonly undecodable: Schema.String;
     }>]>>;
     readonly expiresAtMs: Schema.Finite;
+    readonly startedAtMs: Schema.NullOr<Schema.Finite>;
+    readonly committedAtMs: Schema.NullOr<Schema.Finite>;
     readonly events: Schema.$Array<Schema.Finite>;
 }>;
 export type ActorReceiptRow = typeof ActorReceiptRow.Type;
@@ -718,6 +751,8 @@ export declare const ReceiptsPage: Schema.Struct<{
             readonly undecodable: Schema.String;
         }>]>>;
         readonly expiresAtMs: Schema.Finite;
+        readonly startedAtMs: Schema.NullOr<Schema.Finite>;
+        readonly committedAtMs: Schema.NullOr<Schema.Finite>;
         readonly events: Schema.$Array<Schema.Finite>;
     }>>;
     readonly next: Schema.NullOr<Schema.Struct<{
@@ -805,3 +840,188 @@ export declare const JobTypesPage: Schema.Struct<{
     }>>;
     readonly next: Schema.NullOr<Schema.String>;
 }>;
+/**
+ * Which runner answered a live read and what it covers: its name and region
+ * as the inspector was configured (null when not), when it began recording,
+ * and how many other runners the cluster lists (null when it could not tell).
+ * A live answer is this runner's alone; it covers the deployment only when
+ * `peers` is 0.
+ */
+export declare const LiveScope: Schema.Struct<{
+    readonly runner: Schema.NullOr<Schema.String>;
+    readonly region: Schema.NullOr<Schema.String>;
+    readonly startedAtMs: Schema.Finite;
+    readonly peers: Schema.NullOr<Schema.Finite>;
+}>;
+export type LiveScope = typeof LiveScope.Type;
+/**
+ * One runner's live view of a tenant: its rates, resident activations and
+ * deepest mailbox overall, and per actor type that has either.
+ */
+export declare const LiveOverview: Schema.Struct<{
+    readonly scope: Schema.Struct<{
+        readonly runner: Schema.NullOr<Schema.String>;
+        readonly region: Schema.NullOr<Schema.String>;
+        readonly startedAtMs: Schema.Finite;
+        readonly peers: Schema.NullOr<Schema.Finite>;
+    }>;
+    readonly total: Schema.Struct<{
+        readonly perSecond: Schema.NullOr<Schema.Finite>;
+        readonly p50Ms: Schema.NullOr<Schema.Finite>;
+        readonly p99Ms: Schema.NullOr<Schema.Finite>;
+        readonly awake: Schema.Finite;
+        readonly maxMailbox: Schema.NullOr<Schema.Struct<{
+            readonly depth: Schema.Finite;
+            readonly actorType: Schema.String;
+            readonly actorId: Schema.String;
+        }>>;
+    }>;
+    readonly actorTypes: Schema.$Array<Schema.Struct<{
+        readonly perSecond: Schema.NullOr<Schema.Finite>;
+        readonly p50Ms: Schema.NullOr<Schema.Finite>;
+        readonly p99Ms: Schema.NullOr<Schema.Finite>;
+        readonly actorType: Schema.String;
+        readonly awake: Schema.Finite;
+        readonly maxMailbox: Schema.NullOr<Schema.Struct<{
+            readonly depth: Schema.Finite;
+            readonly actorId: Schema.String;
+        }>>;
+    }>>;
+}>;
+export type LiveOverview = typeof LiveOverview.Type;
+/**
+ * One actor type's commands over a window: the rate at each slot this runner
+ * observed (minutes for `1h`, hours otherwise), oldest first, and each
+ * command's volume; `activity` is null when the runner cannot say.
+ */
+export declare const LiveActivity: Schema.Struct<{
+    readonly scope: Schema.Struct<{
+        readonly runner: Schema.NullOr<Schema.String>;
+        readonly region: Schema.NullOr<Schema.String>;
+        readonly startedAtMs: Schema.Finite;
+        readonly peers: Schema.NullOr<Schema.Finite>;
+    }>;
+    readonly activity: Schema.NullOr<Schema.Struct<{
+        readonly sinceMs: Schema.Finite;
+        readonly points: Schema.$Array<Schema.Struct<{
+            readonly atMs: Schema.Finite;
+            readonly perSecond: Schema.Finite;
+        }>>;
+        readonly commands: Schema.$Array<Schema.Struct<{
+            readonly command: Schema.String;
+            readonly count: Schema.Finite;
+            readonly perSecond: Schema.Finite;
+        }>>;
+    }>>;
+}>;
+export type LiveActivity = typeof LiveActivity.Type;
+/** One actor type's turn times over a window as a histogram and percentiles; null when the runner cannot say. */
+export declare const LiveLatency: Schema.Struct<{
+    readonly scope: Schema.Struct<{
+        readonly runner: Schema.NullOr<Schema.String>;
+        readonly region: Schema.NullOr<Schema.String>;
+        readonly startedAtMs: Schema.Finite;
+        readonly peers: Schema.NullOr<Schema.Finite>;
+    }>;
+    readonly latency: Schema.NullOr<Schema.Struct<{
+        readonly sinceMs: Schema.Finite;
+        readonly count: Schema.Finite;
+        readonly buckets: Schema.$Array<Schema.Struct<{
+            readonly upToMs: Schema.NullOr<Schema.Finite>;
+            readonly count: Schema.Finite;
+        }>>;
+        readonly p50Ms: Schema.NullOr<Schema.Finite>;
+        readonly p95Ms: Schema.NullOr<Schema.Finite>;
+        readonly p99Ms: Schema.NullOr<Schema.Finite>;
+    }>>;
+}>;
+export type LiveLatency = typeof LiveLatency.Type;
+/**
+ * Named actors as this runner holds them: whether each is resident, its
+ * mailbox depth when it is, its open sockets and its open feeds per event.
+ */
+export declare const LiveActors: Schema.Struct<{
+    readonly scope: Schema.Struct<{
+        readonly runner: Schema.NullOr<Schema.String>;
+        readonly region: Schema.NullOr<Schema.String>;
+        readonly startedAtMs: Schema.Finite;
+        readonly peers: Schema.NullOr<Schema.Finite>;
+    }>;
+    readonly actors: Schema.$Array<Schema.Struct<{
+        readonly actorId: Schema.String;
+        readonly awake: Schema.Boolean;
+        readonly mailbox: Schema.NullOr<Schema.Finite>;
+        readonly sockets: Schema.Finite;
+        readonly feeds: Schema.$Array<Schema.Struct<{
+            readonly event: Schema.String;
+            readonly subscribers: Schema.Finite;
+        }>>;
+    }>>;
+}>;
+export type LiveActors = typeof LiveActors.Type;
+/** The tenant's open WebSocket sessions and SSE responses on this runner, overall and per actor type. */
+export declare const LiveConnections: Schema.Struct<{
+    readonly sockets: Schema.Finite;
+    readonly feeds: Schema.Finite;
+    readonly streams: Schema.Finite;
+    readonly watches: Schema.Finite;
+    readonly scope: Schema.Struct<{
+        readonly runner: Schema.NullOr<Schema.String>;
+        readonly region: Schema.NullOr<Schema.String>;
+        readonly startedAtMs: Schema.Finite;
+        readonly peers: Schema.NullOr<Schema.Finite>;
+    }>;
+    readonly byActorType: Schema.$Array<Schema.Struct<{
+        readonly sockets: Schema.Finite;
+        readonly feeds: Schema.Finite;
+        readonly streams: Schema.Finite;
+        readonly watches: Schema.Finite;
+        readonly actorType: Schema.String;
+    }>>;
+}>;
+export type LiveConnections = typeof LiveConnections.Type;
+/**
+ * One committed command as the command stream sends it: its turn's time on
+ * the database clock (`atMs` read after `COMMIT`), its caller key, outcome,
+ * the declared failure's tag, and a bounded, redacted payload preview.
+ */
+export declare const StreamCommand: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly commandId: Schema.String;
+    readonly atMs: Schema.Finite;
+    readonly durationMs: Schema.Finite;
+    readonly actorType: Schema.String;
+    readonly actorId: Schema.String;
+    readonly command: Schema.String;
+    readonly callerKey: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+        readonly json: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly undecodable: Schema.String;
+    }>]>>;
+    readonly outcomeTag: Schema.Literals<readonly ["Success", "Failure"]>;
+    readonly errorTag: Schema.NullOr<Schema.String>;
+    readonly payloadPreview: Schema.NullOr<Schema.String>;
+}>;
+export type StreamCommand = typeof StreamCommand.Type;
+/**
+ * Each cron entry the runtime registers, with the tenant's pending ticks of
+ * it, the soonest one's due time, and the newest committed tick among the
+ * type's newest receipts: its command id, commit time, duration and outcome.
+ */
+export declare const Schedules: Schema.Struct<{
+    readonly schedules: Schema.$Array<Schema.Struct<{
+        readonly actorType: Schema.String;
+        readonly key: Schema.String;
+        readonly expression: Schema.String;
+        readonly command: Schema.String;
+        readonly pending: Schema.Finite;
+        readonly nextDueAtMs: Schema.NullOr<Schema.Finite>;
+        readonly lastRun: Schema.NullOr<Schema.Struct<{
+            readonly commandId: Schema.String;
+            readonly committedAtMs: Schema.Finite;
+            readonly durationMs: Schema.NullOr<Schema.Finite>;
+            readonly outcomeTag: Schema.NullOr<Schema.String>;
+        }>>;
+    }>>;
+}>;
+export type Schedules = typeof Schedules.Type;

package/dist/protocol/inspection.js

@@ -35,9 +35,18 @@ export const ActorRow = Schema.Struct({
     created: Schema.Boolean,
     lastEventSequence: Schema.Finite,
 });
+/**
+ * An actor as a list shows it, with its last command: the command and commit
+ * time of its receipt with the newest recorded commit time among its 256
+ * greatest command ids, null when none of them records one.
+ */
+export const ActorListRow = Schema.Struct({
+    ...ActorRow.fields,
+    lastCommand: Schema.NullOr(Schema.Struct({ command: Schema.String, committedAtMs: Millis })),
+});
 /** 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),
+    actors: Schema.Array(ActorListRow),
     next: Schema.NullOr(Schema.Struct(Identity)),
 });
 /** A staged intent with its target, attempts, last error and due time in epoch milliseconds. */
@@ -112,7 +121,10 @@ export const WorkflowRow = Schema.Struct({
 });
 /**
  * A command receipt with its outcome, expiry in epoch milliseconds and the
- * sequences of the events it emitted.
+ * sequences of the events it emitted. `startedAtMs` is the database clock its
+ * batch's fenced read selected and `committedAtMs` the database clock when
+ * its commit wrote it; both are null on a receipt written before the runtime
+ * recorded them.
  */
 export const ReceiptRow = Schema.Struct({
     commandId: Schema.String,
@@ -121,6 +133,8 @@ export const ReceiptRow = Schema.Struct({
     outcomeTag: Schema.NullOr(Schema.String),
     outcome: Stored,
     expiresAtMs: Millis,
+    startedAtMs: Schema.NullOr(Millis),
+    committedAtMs: Schema.NullOr(Millis),
     events: Schema.Array(Schema.Finite),
 });
 /** A stored event with its sequence, size in bytes and emission time in epoch milliseconds. */
@@ -241,3 +255,138 @@ export const JobTypesPage = Schema.Struct({
     jobTypes: Schema.Array(JobTypeRow),
     next: Schema.NullOr(Schema.String),
 });
+/**
+ * Which runner answered a live read and what it covers: its name and region
+ * as the inspector was configured (null when not), when it began recording,
+ * and how many other runners the cluster lists (null when it could not tell).
+ * A live answer is this runner's alone; it covers the deployment only when
+ * `peers` is 0.
+ */
+export const LiveScope = Schema.Struct({
+    runner: Schema.NullOr(Schema.String),
+    region: Schema.NullOr(Schema.String),
+    startedAtMs: Millis,
+    peers: Schema.NullOr(Schema.Finite),
+});
+/**
+ * A recent rate and turn times: commands per second over the current minute
+ * and the four before it, and the median and 99th percentile turn time over
+ * the last hour, each null when the runner cannot say (or, for a percentile,
+ * when no turn committed). Percentiles are histogram bucket bounds capped by
+ * the slowest turn seen.
+ */
+const LiveRates = {
+    perSecond: Schema.NullOr(Schema.Finite),
+    p50Ms: Schema.NullOr(Schema.Finite),
+    p99Ms: Schema.NullOr(Schema.Finite),
+};
+/** The deepest mailbox among resident activations, null when none is resident. */
+const MaxMailbox = Schema.NullOr(Schema.Struct({ depth: Schema.Finite, actorId: Schema.String }));
+/**
+ * One runner's live view of a tenant: its rates, resident activations and
+ * deepest mailbox overall, and per actor type that has either.
+ */
+export const LiveOverview = Schema.Struct({
+    scope: LiveScope,
+    total: Schema.Struct({
+        ...LiveRates,
+        awake: Schema.Finite,
+        maxMailbox: Schema.NullOr(Schema.Struct({ depth: Schema.Finite, actorType: Schema.String, actorId: Schema.String })),
+    }),
+    actorTypes: Schema.Array(Schema.Struct({
+        actorType: Schema.String,
+        ...LiveRates,
+        awake: Schema.Finite,
+        maxMailbox: MaxMailbox,
+    })),
+});
+/**
+ * One actor type's commands over a window: the rate at each slot this runner
+ * observed (minutes for `1h`, hours otherwise), oldest first, and each
+ * command's volume; `activity` is null when the runner cannot say.
+ */
+export const LiveActivity = Schema.Struct({
+    scope: LiveScope,
+    activity: Schema.NullOr(Schema.Struct({
+        sinceMs: Millis,
+        points: Schema.Array(Schema.Struct({ atMs: Millis, perSecond: Schema.Finite })),
+        commands: Schema.Array(Schema.Struct({ command: Schema.String, count: Schema.Finite, perSecond: Schema.Finite })),
+    })),
+});
+/** One actor type's turn times over a window as a histogram and percentiles; null when the runner cannot say. */
+export const LiveLatency = Schema.Struct({
+    scope: LiveScope,
+    latency: Schema.NullOr(Schema.Struct({
+        sinceMs: Millis,
+        count: Schema.Finite,
+        buckets: Schema.Array(Schema.Struct({ upToMs: Schema.NullOr(Schema.Finite), count: Schema.Finite })),
+        p50Ms: Schema.NullOr(Schema.Finite),
+        p95Ms: Schema.NullOr(Schema.Finite),
+        p99Ms: Schema.NullOr(Schema.Finite),
+    })),
+});
+/**
+ * Named actors as this runner holds them: whether each is resident, its
+ * mailbox depth when it is, its open sockets and its open feeds per event.
+ */
+export const LiveActors = Schema.Struct({
+    scope: LiveScope,
+    actors: Schema.Array(Schema.Struct({
+        actorId: Schema.String,
+        awake: Schema.Boolean,
+        mailbox: Schema.NullOr(Schema.Finite),
+        sockets: Schema.Finite,
+        feeds: Schema.Array(Schema.Struct({ event: Schema.String, subscribers: Schema.Finite })),
+    })),
+});
+const ConnectionCounts = {
+    sockets: Schema.Finite,
+    feeds: Schema.Finite,
+    streams: Schema.Finite,
+    watches: Schema.Finite,
+};
+/** The tenant's open WebSocket sessions and SSE responses on this runner, overall and per actor type. */
+export const LiveConnections = Schema.Struct({
+    scope: LiveScope,
+    ...ConnectionCounts,
+    byActorType: Schema.Array(Schema.Struct({ actorType: Schema.String, ...ConnectionCounts })),
+});
+/**
+ * One committed command as the command stream sends it: its turn's time on
+ * the database clock (`atMs` read after `COMMIT`), its caller key, outcome,
+ * the declared failure's tag, and a bounded, redacted payload preview.
+ */
+export const StreamCommand = Schema.Struct({
+    id: Schema.String,
+    commandId: Schema.String,
+    atMs: Millis,
+    durationMs: Schema.Finite,
+    actorType: Schema.String,
+    actorId: Schema.String,
+    command: Schema.String,
+    callerKey: Stored,
+    outcomeTag: Schema.Literals(["Success", "Failure"]),
+    errorTag: Schema.NullOr(Schema.String),
+    payloadPreview: Schema.NullOr(Schema.String),
+});
+/**
+ * Each cron entry the runtime registers, with the tenant's pending ticks of
+ * it, the soonest one's due time, and the newest committed tick among the
+ * type's newest receipts: its command id, commit time, duration and outcome.
+ */
+export const Schedules = Schema.Struct({
+    schedules: Schema.Array(Schema.Struct({
+        actorType: Schema.String,
+        key: Schema.String,
+        expression: Schema.String,
+        command: Schema.String,
+        pending: Schema.Finite,
+        nextDueAtMs: Schema.NullOr(Millis),
+        lastRun: Schema.NullOr(Schema.Struct({
+            commandId: Schema.String,
+            committedAtMs: Millis,
+            durationMs: Schema.NullOr(Schema.Finite),
+            outcomeTag: Schema.NullOr(Schema.String),
+        })),
+    })),
+});

package/dist/protocol/wire.d.ts

@@ -31,33 +31,10 @@ declare const reasonSchemas: {
         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 cap: Schema.Literals<readonly ["compute", "connections", "spend"]>;
         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 used: Schema.Finite;
+        readonly retryAfterMs: Schema.Finite;
     }>;
     readonly InvalidInput: Schema.TaggedStruct<"InvalidInput", {
         readonly _tag: Schema.tag<"InvalidInput">;
@@ -92,12 +69,6 @@ export declare const envelope: (route: {
     }> | 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"]>;
@@ -112,29 +83,15 @@ export declare const envelope: (route: {
         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 cap: Schema.Literals<readonly ["compute", "connections", "spend"]>;
+        readonly limit: Schema.Finite;
+        readonly used: Schema.Finite;
         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>;

package/dist/protocol/wire.js

@@ -1,5 +1,5 @@
 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";
+import { ActorError, ActorUnavailable, CommandConflict, CommandExpired, InvalidCommandId, InvalidInput, Reason, QuotaExceeded, SessionEnded, 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 = {
@@ -16,9 +16,6 @@ const reasonSchemas = {
     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),
 };
@@ -66,9 +63,6 @@ export const statusOf = (reason) => Match.value(reason).pipe(Match.tagsExhaustiv
     ActorUnavailable: () => 503,
     RunnerAtCapacity: () => 503,
     QuotaExceeded: () => 429,
-    SpendLimitExceeded: () => 402,
-    ConnectionLimitExceeded: () => 429,
-    StorageQuotaExceeded: () => 429,
     Timeout: () => 504,
     NotCreated: () => 404,
     MailboxFull: () => 429,
@@ -81,9 +75,6 @@ export const closeCodeOf = (reason) => Match.value(reason).pipe(Match.tagsExhaus
     ActorUnavailable: () => 1013,
     RunnerAtCapacity: () => 1013,
     QuotaExceeded: () => 1008,
-    SpendLimitExceeded: () => 1008,
-    ConnectionLimitExceeded: () => 1008,
-    StorageQuotaExceeded: () => 1008,
     NotCreated: () => 4404,
     Unauthorized: (unauthorized) => unauthorized.code === "reauthorization_unavailable" ? 1013 : 1008,
     InvalidInput: () => 4400,

package/dist/runtime/actors.d.ts

@@ -1,3 +1,4 @@
+import type { LiveRuntime } from "./telemetry/live.ts";
 import { Context, type Effect, type Scope, type Stream } from "effect";
 import type { Transport } from "./connections/transport.ts";
 import type { Holder } from "./connections/holder.ts";
@@ -18,6 +19,8 @@ declare const InternalActors_base: Context.ServiceClass<InternalActors, "@rikala
     readonly transport: Transport;
     /** This runner's in-process connection holder. */
     readonly holder: Holder;
+    /** What this runner knows only in memory, for the inspector's live reads. */
+    readonly live: LiveRuntime["Service"];
     /** Ends the actor's activation on this runner as idle expiry would. */
     readonly hibernate: (ref: ActorRef) => Effect.Effect<void>;
     readonly execute: (request: Request) => Effect.Effect<Executed, ActorError>;

package/dist/runtime/app.d.ts

@@ -0,0 +1,65 @@
+import { type Crypto, Layer, Schema } from "effect";
+import type { SqlClient } from "effect/sql";
+import type { layer } from "./layer.ts";
+export declare const TypeId: unique symbol;
+/** What `Actors.layer` provides: the actor runtime every handler layer registers with. */
+type RuntimeServices = Layer.Success<ReturnType<typeof layer>>;
+/**
+ * Every service a hosted app's layer may require. The host builds
+ * `Actors.layer` over its own database and provides it with the SQL client and
+ * `Crypto`, so an app never constructs a runtime and a requirement outside
+ * this union is a compile error at `App.make`.
+ */
+export type AppServices = RuntimeServices | SqlClient.SqlClient | Crypto.Crypto;
+declare const AppLayerFailed_base: Schema.Class<AppLayerFailed, Schema.TaggedStruct<"AppLayerFailed", {
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/** Building the app's layer failed; `cause` is what the layer failed with. */
+export declare class AppLayerFailed extends AppLayerFailed_base {
+}
+/**
+ * An actor definition as an app declares it: its name, which `Actors.serve`
+ * routes by, and its declared members, which `checkWorkflows` compares with
+ * stored executions before a rollout.
+ */
+export interface AppActor {
+    readonly name: string;
+    readonly api: object;
+}
+/**
+ * A hosted app: the actor definitions to serve and one layer that registers
+ * their handlers and builds any services they need from `AppServices` alone.
+ */
+export interface App {
+    readonly [TypeId]: typeof TypeId;
+    readonly actors: ReadonlyArray<AppActor>;
+    readonly layer: Layer.Layer<never, AppLayerFailed, AppServices>;
+}
+/**
+ * Declares a hosted app, the default export of `src/app.ts`. Any handler
+ * requirement the layer leaves unprovided fails to compile here, which is why
+ * the host accepts only values this constructor branded: a layer's
+ * requirements cannot be checked at run time. A failure building the layer
+ * becomes `AppLayerFailed`, so a host that loads the app knows its error type.
+ *
+ * @example
+ * ```ts
+ * export default App.make({ actors: [Counter], layer: CounterLive })
+ * ```
+ */
+declare const make: <E = never>(app: {
+    readonly actors: ReadonlyArray<AppActor>;
+    readonly layer: Layer.Layer<never, E, AppServices>;
+}) => App;
+/**
+ * Whether `value` is an app `App.make` built: branded, with actors that each
+ * have a name and an `api` object, and a layer. A loader uses it on a module's default export before providing the
+ * layer.
+ */
+declare const is: (value: unknown) => value is App;
+/** Hosted app declaration and the loader's check of a module's default export. */
+export declare const App: {
+    make: typeof make;
+    is: typeof is;
+};
+export {};