@rikalabs/akter 0.1.0-alpha.0 → 0.1.0-alpha.3

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", "storage", "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", "storage", "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/adoption/backfill.js

@@ -42,7 +42,7 @@ const backfillTable = Effect.fnUntraced(function* (target, batch) {
     WHERE table_schema = ${target.schema} AND table_name = ${target.table}`;
     if (adoption === undefined)
         return yield* AdoptionRefused.make({
-            message: `${name} is not observed; run durable adopt observe ${target.table} first`,
+            message: `${name} is not observed; run akter adopt observe ${target.table} first`,
         });
     if (adoption.mode === "enforce")
         return yield* AdoptionRefused.make({

package/dist/runtime/adoption/enforce.js

@@ -53,7 +53,7 @@ const enforcementRefusals = Effect.fnUntraced(function* (target, options) {
          OR ${identifier(target.tenantColumn)}::text = '' OR ${identifier(target.actorColumn)}::text = '')::text AS unowned
      FROM ${table}`);
     if (Number(counts.unfilled) > 0)
-        refusals.push(`${counts.unfilled} rows of ${name} have no routing_key; run durable adopt backfill ${target.table}`);
+        refusals.push(`${counts.unfilled} rows of ${name} have no routing_key; run akter adopt backfill ${target.table}`);
     if (Number(counts.unowned) > 0)
         refusals.push(`${counts.unowned} rows of ${name} have a NULL or empty ${target.tenantColumn} or ${target.actorColumn}, so no actor owns them`);
     const recent = yield* sql `
@@ -152,7 +152,7 @@ export const enforceAdoption = Effect.fnUntraced(function* (actors, options) {
           WHERE table_schema = ${target.schema} AND table_name = ${target.table} FOR UPDATE`;
             if (adoption === undefined)
                 return yield* AdoptionRefused.make({
-                    message: `${name} is not observed; run durable adopt observe ${target.table} first`,
+                    message: `${name} is not observed; run akter adopt observe ${target.table} first`,
                 });
             if (adoption.mode === "enforce")
                 return yield* AdoptionRefused.make({ message: `${name} is already enforced` });

package/dist/runtime/adoption/observe.js

@@ -66,7 +66,7 @@ export const observeAdoption = Effect.fnUntraced(function* (actors, only, lockTi
                 });
             if (existing?.mode === "enforce")
                 return yield* AdoptionRefused.make({
-                    message: `${name} is enforced; run durable adopt release ${target.table} --to observe first`,
+                    message: `${name} is enforced; run akter adopt release ${target.table} --to observe first`,
                 });
             const [column] = yield* sql `
         SELECT t.typname AS type FROM pg_attribute a

package/dist/runtime/adoption/plan.d.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { SqlClient } from "effect/sql";
 import { type AdoptionTarget } from "./target.ts";
-/** What `durable adopt plan` reports for one table; it changes nothing. */
+/** What `akter adopt plan` reports for one table; it changes nothing. */
 export interface AdoptionPlan {
     readonly table: string;
     readonly actor: string;

package/dist/runtime/adoption/startup.js

@@ -32,7 +32,7 @@ export const checkEnforcedTable = Effect.fnUntraced(function* ({ target, writerR
     ]) {
         const found = triggers.find((trigger) => trigger.name === name);
         if (found === undefined)
-            return yield* refuse(`is enforced but its guard trigger ${name} is missing; run durable adopt release ${target.table} --to observe and enforce it again`);
+            return yield* refuse(`is enforced but its guard trigger ${name} is missing; run akter adopt release ${target.table} --to observe and enforce it again`);
         if (found.enabled !== "A")
             return yield* refuse(`is enforced but its guard trigger ${name} is not enabled always; run ALTER TABLE ${target.table} ENABLE ALWAYS TRIGGER ${name}`);
         if (found.function !== "actor_adoption_guard" || found.type !== type)

package/dist/runtime/adoption/status.d.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { SqlClient } from "effect/sql";
-/** One adopted table as `durable adopt status` reports it. */
+/** One adopted table as `akter adopt status` reports it. */
 export interface AdoptionStatus {
     readonly table: string;
     readonly actor: string;