@rikalabs/akter 0.1.0-alpha.0

package/dist/runtime/entity/mailbox.js

@@ -0,0 +1,121 @@
+import { Latch } from "effect";
+/**
+ * The most commands one turn batch runs. It stays below the 64 open
+ * subtransactions past which Postgres overflows its per-backend subtransaction
+ * cache, since a batch of an actor whose handlers issue statements can hold a
+ * savepoint per command.
+ */
+export const BATCH_CAP = 32;
+/**
+ * The most calls of one commutative reducer that one merged turn combines.
+ * Merging never waits for calls: it takes only those already waiting.
+ */
+export const MERGE_CAP = 1024;
+/**
+ * The most command ids an activation keeps to run alone after a failed batch.
+ * An id leaves the set when its retry is taken, and a caller that never
+ * retries would otherwise leave it for the activation's lifetime. Past the
+ * cap the oldest go first: an evicted id's late retry may join a batch again,
+ * which a retryable failure makes safe.
+ */
+export const ALONE_CAP = BATCH_CAP * 32;
+/** Adds `ids` to `alone` as its newest entries, then drops the oldest past `ALONE_CAP`. */
+export const markAlone = ({ alone, ids, }) => {
+    for (const id of ids) {
+        alone.delete(id);
+        alone.add(id);
+    }
+    for (const oldest of alone) {
+        if (alone.size <= ALONE_CAP)
+            return;
+        alone.delete(oldest);
+    }
+};
+/** True when `next` joins a merged turn of `previous`'s commutative reducer. */
+export const merges = ({ previous, next, }) => next.command.merge !== undefined && next.request.command === previous.request.command;
+/**
+ * Removes the next batch from the front of `waiting`, in delivery order: the
+ * first command, then each command behind it that is already waiting, up to
+ * `BATCH_CAP` turns. Consecutive calls of one commutative reducer are one
+ * merged turn of up to `MERGE_CAP` calls. Nothing waits for more to arrive. A
+ * command joins a batch only once its own `queued` hook has finished, so the
+ * batch stops at the first command that is still in it, and takes nothing when
+ * that is the first.
+ *
+ * A batch stops before a command id it already holds, so a retry queued
+ * behind its original resolves through the receipt the original commits. It
+ * also stops before a command listed in `alone`, and such a command runs in a
+ * batch of its own, once: these are the commands of a batch that failed, run
+ * one per transaction until each has been processed.
+ */
+export const takeBatch = ({ waiting, alone, }) => {
+    if (waiting[0]?.queued !== true)
+        return [];
+    const first = waiting.shift();
+    if (alone.delete(first.request.commandId))
+        return [first];
+    const batch = [first];
+    const ids = new Set([first.request.commandId]);
+    let turns = 1;
+    let merged = first.command.merge === undefined ? 0 : 1;
+    while (waiting.length > 0) {
+        const next = waiting[0];
+        const { commandId } = next.request;
+        if (!next.queued || ids.has(commandId) || alone.has(commandId))
+            break;
+        const joins = merged > 0 && merged < MERGE_CAP && merges({ previous: batch.at(-1), next });
+        if (!joins && turns === BATCH_CAP)
+            break;
+        if (joins)
+            merged += 1;
+        else {
+            turns += 1;
+            merged = next.command.merge === undefined ? 0 : 1;
+        }
+        ids.add(commandId);
+        batch.push(waiting.shift());
+    }
+    return batch;
+};
+/**
+ * One activation handler's waiting commands in arrival order, and its
+ * worker's wake-up. A command is offered as Cluster delivers it and becomes
+ * takeable once its `queued` hook finished; the wake-up stays open while the
+ * front command is takeable, so the worker never sleeps past ready work and a
+ * command whose hook is still running holds back every command behind it.
+ * `alone` outlives the handler: it holds the ids of a failed batch, each run
+ * in a transaction of its own once.
+ */
+export const activationMailbox = (alone) => {
+    const waiting = [];
+    const ready = Latch.makeUnsafe(false);
+    return {
+        offer: (entry) => {
+            waiting.push(entry);
+        },
+        /** Marks `entry`'s `queued` hook finished, so a batch may take it. */
+        queued: (entry) => {
+            entry.queued = true;
+            ready.openUnsafe();
+        },
+        /** Waits until the front command may be takeable. */
+        await: ready.await,
+        /** The next batch, possibly empty; the wake-up closes once the front command is not takeable. */
+        take: () => {
+            const batch = takeBatch({ waiting, alone });
+            if (waiting[0]?.queued !== true)
+                ready.closeUnsafe();
+            return batch;
+        },
+        /** Puts taken commands back in front of everything that arrived since. */
+        requeue: (entries) => {
+            if (entries.length === 0)
+                return;
+            waiting.unshift(...entries);
+            ready.openUnsafe();
+        },
+        /** Runs each of `ids` alone once, the next time it is taken. */
+        isolate: (ids) => markAlone({ alone, ids }),
+        size: () => waiting.length,
+    };
+};

package/dist/runtime/entity/register.d.ts

@@ -0,0 +1,424 @@
+import { type Crypto, Effect, Schema, Scope, Stream } from "effect";
+import { Entity, Sharding } from "effect/cluster";
+import { Rpc } from "effect/rpc";
+import { SqlClient } from "effect/sql";
+import { ActorError } from "../../errors/actor.ts";
+import { DeliveryFailed } from "../request.ts";
+import { type Registration } from "../members.ts";
+import { ActorRef } from "../../identity/caller.ts";
+import type { Authorize } from "../connections/streams.ts";
+import type { Transport } from "../connections/transport.ts";
+import { DefectLog } from "../telemetry/defects.ts";
+/**
+ * The commands an activation holds, waiting and in its current batch, when its
+ * policy declares no `mailboxCapacity`. Cluster refuses the next, which
+ * dispatch answers `ActorUnavailable`: a hot actor's backlog then waits in its
+ * callers' retries, where it holds no memory or turn connection on this runner.
+ */
+export declare const ACTIVATION_MAILBOX = 1024;
+/** Encodes a tenant and actor id as the Cluster entity id. */
+export declare const encodeEntityId: (tenantAndId: readonly [string, string]) => Effect.Effect<string, Schema.SchemaError, never>;
+/**
+ * What a runner knows of one activation when a delivery to it times out: the
+ * handlers Cluster has built for it and whether one is being built, the
+ * worker's phase, the commands waiting in its mailbox and in its current
+ * batch, and whether an in-place restart is running.
+ */
+export interface ActivationDiagnosis {
+    readonly handlers: number;
+    readonly building: boolean;
+    readonly worker: "none" | "idle" | "turn" | "workflow kick" | "restarting";
+    readonly mailbox: number;
+    readonly batch: number;
+}
+/** The command entity definition for an actor type, created once per name. */
+export declare const commandEntity: (name: string) => Entity.Entity<string, Rpc.Rpc<"Execute", Schema.Struct<{
+    readonly ref: Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly caller: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"User", {
+        readonly subject: Schema.NonEmptyString;
+    }>, Schema.TaggedStruct<"Anonymous", {}>, Schema.TaggedStruct<"System", {
+        readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription"]>;
+        readonly ref: Schema.optional<Schema.Struct<{
+            readonly tenant: Schema.NonEmptyString;
+            readonly actor: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>>;
+        readonly onBehalfOf: Schema.optional<Schema.Struct<{
+            readonly subject: Schema.NonEmptyString;
+        }>>;
+        readonly mint: Schema.optional<Schema.Struct<{
+            readonly commandId: Schema.String;
+            readonly ordinal: Schema.Int;
+        }>>;
+    }>]>;
+    readonly command: Schema.NonEmptyString;
+    readonly commandId: Schema.String;
+    readonly payload: Schema.String;
+    readonly external: Schema.optionalKey<Schema.Boolean>;
+    readonly clockOffset: Schema.optionalKey<Schema.Finite>;
+    readonly redelivered: Schema.optionalKey<Schema.Boolean>;
+    readonly intent: Schema.optionalKey<Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>>;
+    readonly delivery: Schema.optionalKey<Schema.Struct<{
+        readonly subscription: Schema.NonEmptyString;
+        readonly sourceType: Schema.NonEmptyString;
+        readonly sourceId: Schema.NonEmptyString;
+        readonly epoch: Schema.String;
+        readonly kind: Schema.Literals<readonly ["event", "gap", "rejected"]>;
+        readonly position: Schema.String;
+    }>>;
+    readonly queuedAtMs: Schema.optionalKey<Schema.Finite>;
+    readonly usageToken: Schema.optionalKey<Schema.NonEmptyString>;
+}>, Schema.Struct<{
+    readonly outcome: Schema.TaggedUnion<{
+        readonly Acknowledged: Schema.TaggedStruct<"Acknowledged", {
+            readonly reason: Schema.Literals<readonly ["AlreadyApplied", "Stale", "Unsubscribed", "NotCreated"]>;
+        }>;
+        readonly Defect: Schema.TaggedStruct<"Defect", {
+            readonly cause: Schema.Defect;
+        }>;
+        readonly Failure: Schema.TaggedStruct<"Failure", {
+            readonly value: Schema.String;
+        }>;
+        readonly Success: Schema.TaggedStruct<"Success", {
+            readonly value: Schema.String;
+        }>;
+    }>;
+    readonly version: Schema.optionalKey<Schema.String>;
+    readonly endedAtMs: Schema.optionalKey<Schema.Finite>;
+    readonly replayed: Schema.optionalKey<Schema.Boolean>;
+}>, Schema.Union<readonly [typeof ActorError, typeof DeliveryFailed]>, never, never> | Rpc.Rpc<"Wake", Schema.Void, Schema.Void, Schema.Never, never, never>>;
+/** The connection entity definition for an actor type, created once per name. */
+export declare const connectionEntity: (name: string) => Entity.Entity<`${string}/Connections`, Rpc.Rpc<"Close", Schema.Struct<{
+    ref: Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    connectionId: Schema.String;
+    holder: Schema.String;
+    holderEpoch: Schema.String;
+    cause: typeof import("../../index.ts").SessionEnded;
+}>, Schema.Void, typeof ActorError, never, never> | Rpc.Rpc<"Frame", Schema.Struct<{
+    ref: Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    connectionId: Schema.String;
+    holder: Schema.String;
+    holderEpoch: Schema.String;
+    seq: Schema.Finite;
+    frame: Schema.String;
+    authorizedUntil: Schema.Finite;
+    commands: Schema.Struct<{
+        readonly secret: Schema.String;
+        readonly seq: Schema.Finite;
+        readonly issuedAt: Schema.Finite;
+        readonly expiresAt: Schema.Finite;
+    }>;
+}>, Schema.TaggedUnion<{
+    readonly Acked: Schema.TaggedStruct<"Acked", {
+        generation: Schema.String;
+        owner: Schema.String;
+        ownerEpoch: Schema.String;
+    }>;
+    readonly Closed: Schema.TaggedStruct<"Closed", {
+        readonly ended: typeof import("../../index.ts").SessionEnded;
+    }>;
+}>, typeof ActorError, never, never> | Rpc.Rpc<"Open", Schema.Struct<{
+    ref: Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    connectionId: Schema.String;
+    holder: Schema.String;
+    holderEpoch: Schema.String;
+    member: Schema.String;
+    caller: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"User", {
+        readonly subject: Schema.NonEmptyString;
+    }>, Schema.TaggedStruct<"Anonymous", {}>, Schema.TaggedStruct<"System", {
+        readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription"]>;
+        readonly ref: Schema.optional<Schema.Struct<{
+            readonly tenant: Schema.NonEmptyString;
+            readonly actor: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>>;
+        readonly onBehalfOf: Schema.optional<Schema.Struct<{
+            readonly subject: Schema.NonEmptyString;
+        }>>;
+        readonly mint: Schema.optional<Schema.Struct<{
+            readonly commandId: Schema.String;
+            readonly ordinal: Schema.Int;
+        }>>;
+    }>]>;
+    params: Schema.String;
+    commands: Schema.Struct<{
+        readonly secret: Schema.String;
+        readonly seq: Schema.Finite;
+        readonly issuedAt: Schema.Finite;
+        readonly expiresAt: Schema.Finite;
+    }>;
+}>, Schema.TaggedUnion<{
+    readonly Failed: Schema.TaggedStruct<"Failed", {
+        readonly value: Schema.String;
+    }>;
+    readonly Opened: Schema.TaggedStruct<"Opened", {
+        readonly generation: Schema.String;
+        readonly owner: Schema.String;
+        readonly ownerEpoch: Schema.String;
+        readonly baseline: Schema.String;
+        readonly recovered: Schema.optional<Schema.Boolean>;
+    }>;
+}>, typeof ActorError, never, never> | Rpc.Rpc<"Progress", Schema.Struct<{
+    ref: Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    jobId: Schema.String;
+    job: Schema.String;
+    attempt: Schema.Finite;
+    seq: Schema.Finite;
+    leaseUntil: Schema.Finite;
+    frame: Schema.String;
+}>, Schema.Void, Schema.Never, never, never> | Rpc.Rpc<"ProgressClosed", Schema.Struct<{
+    ref: Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    jobId: Schema.String;
+    attempt: Schema.Finite;
+}>, Schema.Void, Schema.Never, never, never> | Rpc.Rpc<"Resync", Schema.Struct<{
+    ref: Schema.Struct<{
+        readonly tenant: Schema.NonEmptyString;
+        readonly actor: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    connectionId: Schema.String;
+    holder: Schema.String;
+    holderEpoch: Schema.String;
+    after: Schema.optional<Schema.String>;
+    authorizedUntil: Schema.Finite;
+}>, Schema.TaggedUnion<{
+    readonly Closed: Schema.TaggedStruct<"Closed", {
+        readonly ended: typeof import("../../index.ts").SessionEnded;
+    }>;
+    readonly Replayed: Schema.TaggedStruct<"Replayed", {
+        generation: Schema.String;
+        owner: Schema.String;
+        ownerEpoch: Schema.String;
+    }>;
+}>, typeof ActorError, never, never> | Rpc.Rpc<"Subscribe", Schema.Struct<{
+    member: Schema.String;
+    caller: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"User", {
+        readonly subject: Schema.NonEmptyString;
+    }>, Schema.TaggedStruct<"Anonymous", {}>, Schema.TaggedStruct<"System", {
+        readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription"]>;
+        readonly ref: Schema.optional<Schema.Struct<{
+            readonly tenant: Schema.NonEmptyString;
+            readonly actor: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>>;
+        readonly onBehalfOf: Schema.optional<Schema.Struct<{
+            readonly subject: Schema.NonEmptyString;
+        }>>;
+        readonly mint: Schema.optional<Schema.Struct<{
+            readonly commandId: Schema.String;
+            readonly ordinal: Schema.Int;
+        }>>;
+    }>]>;
+    input: Schema.String;
+    authorizedUntil: Schema.Finite;
+}>, import("effect/rpc/RpcSchema").Stream<Schema.TaggedUnion<{
+    readonly Done: Schema.TaggedStruct<"Done", {}>;
+    readonly Element: Schema.TaggedStruct<"Element", {
+        readonly value: Schema.String;
+    }>;
+    readonly Started: Schema.TaggedStruct<"Started", {
+        readonly owner: Schema.String;
+        readonly ownerEpoch: Schema.String;
+    }>;
+}>, Schema.Union<readonly [typeof ActorError, Schema.TaggedStruct<"StreamFailed", {
+    readonly value: Schema.String;
+}>]>>, Schema.Never, never, never>>;
+/**
+ * Registers an actor type's command entity with Cluster and starts its
+ * activations, worker, and singleton keeper.
+ *
+ * - One worker per handler runs queued commands as turn batches in delivery
+ *   order, so an activation has one transaction in flight. Commands enqueue
+ *   synchronously when Cluster delivers the request, and replies follow the
+ *   batch's commit; broadcasts go out first. With `pipelining`, the next batch
+ *   already waiting is taken while the previous one commits. Its admission
+ *   waits until a batch with a workflow command is published, because that
+ *   batch's kick can re-arm a running execution's timer under the generation
+ *   row lock the admission would hold, and the next batch may be the very call
+ *   that execution's activity is waiting on.
+ * - A retryable failure committed nothing. The worker ends the activation,
+ *   waits its backoff, starts the next one in place, and only then answers each
+ *   unanswered command `ActorUnavailable`, so a caller never retries into the
+ *   closed activation and never waits out its delivery timeout when Cluster
+ *   would drop a re-sent command mid-restart (as during a database failover).
+ *   Restarts never overlap because the one worker serializes them.
+ * - A defect aborts the whole batch; a following batch whose admission was
+ *   already sent is rolled back unseen. After a deterministic defect the
+ *   failed batch's commands rerun one per transaction so one bad command cannot
+ *   keep rolling back its neighbours, and a lone command answers `Defect`.
+ *   Defect hooks do not run, since they can loop on corrupt state. A defect
+ *   after the batch committed lets redelivered commands replay their receipts.
+ * - Restart backoff is kept per activation, because Cluster's own is shared by
+ *   every entity of the type and never resets.
+ * - Each handler's resources live in a child of the entity's scope, closed when
+ *   a rebuild supersedes it, the handler closes, or the entity ends, because a
+ *   defect during shutdown can drop the superseded handler's own scope.
+ * - Full-mailbox and full-runner rejections share one Cluster error; only an
+ *   activation already resident can have a full mailbox, and a rebuilt handler
+ *   can overlap its predecessor, hence the count.
+ * - A singleton starts only on the runner holding its shard's lease. Every
+ *   runner serves its entity, and one keeper re-wakes the default tenant's
+ *   instance so it moves to a survivor. A failing singleton build answers every
+ *   command with its defect instead of retrying forever.
+ * - A draining runner refuses a batch, or interrupts its run at the deadline,
+ *   and every unanswered caller retries elsewhere.
+ * - The turn span carries no captured stack: its call site is always this file.
+ */
+export declare const registerActor: (registration: Registration, transport: Transport, authorize: Authorize, gate: {
+    run: <A, E, R>(turn: Effect.Effect<A, E, R>) => Effect.Effect<A, E | ActorError, R>;
+    readonly open: boolean;
+    close: Effect.Effect<void, never, never>;
+    expire: Effect.Effect<number, never, never>;
+}, writable: Effect.Effect<void, ActorError, never>) => Effect.Effect<{
+    isResident: (entityId: string) => boolean;
+    owner: {
+        activations: Map<string, import("../connections/owner.ts").Activation>;
+        hasConnections: boolean;
+        hasStreams: boolean;
+        hasProgress: boolean;
+        progress: (activation: import("../connections/owner.ts").Activation, message: import("../connections/owner.ts").ProgressDelivery) => Effect.Effect<void, never, Entity.CurrentAddress | Sharding.Sharding | SqlClient.SqlClient>;
+        closeProgress: (activation: import("../connections/owner.ts").Activation, jobId: string) => Effect.Effect<void, never, SqlClient.SqlClient>;
+        progressClosed: (activation: import("../connections/owner.ts").Activation, message: {
+            readonly ref: ActorRef;
+            readonly jobId: string;
+            readonly attempt: number;
+        }) => Effect.Effect<void, never, SqlClient.SqlClient>;
+        feedBroadcasts: (committed: import("../turn/execute.ts").CommittedEvents) => Effect.Effect<import("../members.ts").Broadcast[], never, never>;
+        watchBroadcasts: (activation: import("../connections/owner.ts").Activation, writes: import("../connections/protocol.ts").WriteSet, version: string) => Effect.Effect<import("../members.ts").Broadcast[], never, never>;
+        hibernate: (entityId: string) => Effect.Effect<void, never, SqlClient.SqlClient>;
+        subscribe: (activation: import("../connections/owner.ts").Activation, request: {
+            readonly member: string;
+            readonly caller: import("../../index.ts").Caller;
+            readonly input: string;
+            readonly authorizedUntil: number;
+        }) => Stream.Stream<{
+            readonly _tag: "Done";
+        } | {
+            readonly _tag: "Element";
+            readonly value: string;
+        } | {
+            readonly _tag: "Started";
+            readonly owner: string;
+            readonly ownerEpoch: string;
+        }, ActorError | {
+            readonly _tag: "StreamFailed";
+            readonly value: string;
+        }, SqlClient.SqlClient>;
+        endStreams: (activation: import("../connections/owner.ts").Activation) => Effect.Effect<void, never, never>;
+        watchStreams: Effect.Effect<void, never, never>;
+        enter: (entityId: string, ref: ActorRef, key: bigint) => Effect.Effect<import("../connections/owner.ts").Activation, never, Scope.Scope | SqlClient.SqlClient>;
+        prepare: (activation: import("../connections/owner.ts").Activation) => Effect.Effect<void, never, Entity.CurrentAddress | Sharding.Sharding | SqlClient.SqlClient>;
+        list: (activation: import("../connections/owner.ts").Activation) => (member: string) => Effect.Effect<readonly import("../members.ts").OpenConnection[], never, never>;
+        flush: (activation: import("../connections/owner.ts").Activation, broadcasts: ReadonlyArray<import("../members.ts").Broadcast>, head: string, own?: {
+            readonly connectionId: string;
+            readonly member: string;
+            readonly frames: import("../members.ts").ConnectionResult["sends"];
+            readonly replay?: boolean;
+        }) => Effect.Effect<void, never, SqlClient.SqlClient>;
+        open: (activation: import("../connections/owner.ts").Activation, request: {
+            readonly ref: ActorRef;
+            readonly connectionId: string;
+            readonly holder: string;
+            readonly holderEpoch: string;
+        } & {
+            readonly member: string;
+            readonly caller: import("../../index.ts").Caller;
+            readonly params: string;
+            readonly commands: import("../../identity/connection.ts").ConnectionCommands;
+        }) => Effect.Effect<{
+            generation: string;
+            owner: string;
+            ownerEpoch: string;
+            _tag: "Opened";
+            baseline: string;
+            recovered: boolean;
+            value?: undefined;
+        } | {
+            _tag: "Failed";
+            value: string;
+        } | {
+            generation: string;
+            owner: string;
+            ownerEpoch: string;
+            value?: undefined;
+            _tag: "Opened";
+            baseline: string;
+        }, ActorError, Entity.CurrentAddress | Sharding.Sharding | SqlClient.SqlClient>;
+        frame: (activation: import("../connections/owner.ts").Activation, request: {
+            readonly ref: ActorRef;
+            readonly connectionId: string;
+            readonly holder: string;
+            readonly holderEpoch: string;
+        } & {
+            readonly seq: number;
+            readonly frame: string;
+            readonly authorizedUntil: number;
+            readonly commands: import("../../identity/connection.ts").ConnectionCommands;
+        }) => Effect.Effect<{
+            _tag: "Closed";
+            ended: import("../../index.ts").SessionEnded;
+        } | {
+            generation: string;
+            owner: string;
+            ownerEpoch: string;
+            _tag: "Acked";
+        }, ActorError, Entity.CurrentAddress | Sharding.Sharding | SqlClient.SqlClient>;
+        close: (activation: import("../connections/owner.ts").Activation, request: {
+            readonly ref: ActorRef;
+            readonly connectionId: string;
+            readonly holder: string;
+            readonly holderEpoch: string;
+        } & {
+            readonly cause: import("../../index.ts").SessionEnded;
+        }) => Effect.Effect<void, ActorError, Entity.CurrentAddress | Sharding.Sharding | SqlClient.SqlClient>;
+        resync: (activation: import("../connections/owner.ts").Activation, request: {
+            readonly ref: ActorRef;
+            readonly connectionId: string;
+            readonly holder: string;
+            readonly holderEpoch: string;
+        } & {
+            readonly after?: string | undefined;
+            readonly authorizedUntil: number;
+        }) => Effect.Effect<{
+            _tag: "Closed";
+            ended: import("../../index.ts").SessionEnded;
+        } | {
+            generation: string;
+            owner: string;
+            ownerEpoch: string;
+            _tag: "Replayed";
+        }, ActorError, Entity.CurrentAddress | Sharding.Sharding | SqlClient.SqlClient>;
+    };
+    /** This type's view of one activation, for a delivery that timed out. */
+    diagnose: (entityId: string) => ActivationDiagnosis;
+    /** Activations of this type being rebuilt or restarted in place now. */
+    restarting: () => string[];
+}, never, Crypto.Crypto | DefectLog | Scope.Scope | Sharding.Sharding | SqlClient.SqlClient>;