effect-actors 0.0.1

package/dist/runtime/cluster/protocol.js

@@ -0,0 +1,69 @@
+import { Schema } from "effect";
+import { ClusterSchema, Entity } from "effect/unstable/cluster";
+import { Rpc } from "effect/unstable/rpc";
+import { CommandErrorSchema, EventErrorSchema, HostedErrorSchema, ReadErrorSchema, } from "../../errors/index.js";
+import * as Wire from "../../protocol/schemas.js";
+const Command = Rpc.make("Command", {
+    payload: {
+        commandId: Schema.String,
+        fingerprint: Schema.String,
+        protocolVersion: Schema.Int,
+        command: Schema.String,
+        payload: Schema.Json,
+        expectedRevision: Schema.optionalKey(Schema.String),
+    },
+    success: Wire.Receipt,
+    error: CommandErrorSchema,
+    primaryKey: ({ commandId, fingerprint }) => JSON.stringify([commandId, fingerprint]),
+})
+    .annotate(ClusterSchema.Persisted, true)
+    .annotate(ClusterSchema.Uninterruptible, "server");
+const Query = Rpc.make("Query", {
+    payload: { query: Schema.String, protocolVersion: Schema.Int, payload: Schema.Json },
+    success: Wire.QueryResult,
+    error: ReadErrorSchema,
+});
+const Receipt = Rpc.make("Receipt", {
+    payload: { commandId: Schema.String },
+    success: Schema.NullOr(Wire.Receipt),
+    error: ReadErrorSchema,
+});
+const Events = Rpc.make("Events", {
+    payload: { after: Schema.String, limit: Schema.Int },
+    success: Wire.EventPage,
+    error: EventErrorSchema,
+});
+const Wake = Rpc.make("Wake", {
+    payload: { timerId: Schema.String, generation: Schema.String, dueAtMillis: Schema.Number },
+    success: Schema.NullOr(Wire.Receipt),
+    error: CommandErrorSchema,
+});
+const actionFields = {
+    action: Schema.String,
+    protocolVersion: Schema.Int,
+    payload: Schema.Json,
+    requestKey: Schema.optionalKey(Schema.String),
+    fingerprint: Schema.String,
+};
+const Action = Rpc.make("Action", {
+    payload: actionFields,
+    success: Wire.Outcome,
+    error: HostedErrorSchema,
+});
+const DurableAction = Rpc.make("DurableAction", {
+    payload: actionFields,
+    success: Wire.Outcome,
+    error: HostedErrorSchema,
+    primaryKey: ({ requestKey, fingerprint }) => JSON.stringify([requestKey, fingerprint]),
+})
+    .annotate(ClusterSchema.Persisted, true)
+    .annotate(ClusterSchema.Uninterruptible, "server");
+export const makeEntity = (namespace, actorType) => Entity.make(`effect-actors/${JSON.stringify([namespace, actorType])}`, [
+    Command,
+    Query,
+    Receipt,
+    Events,
+    Wake,
+    Action,
+    DurableAction,
+]).annotate(ClusterSchema.ShardGroup, () => namespace);

package/dist/runtime/configuration.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import { RegistrationError } from "../errors/index.js";
+import type { Configuration } from "./service.js";
+export declare const validate: (configuration: Configuration) => Effect.Effect<Configuration, RegistrationError>;

package/dist/runtime/configuration.js

@@ -0,0 +1,34 @@
+import { Duration, Effect } from "effect";
+import { RegistrationError } from "../errors/index.js";
+export const validate = (configuration) => Effect.try({
+    try: () => {
+        if (typeof configuration.namespace !== "string" ||
+            configuration.namespace.length < 1 ||
+            configuration.namespace.length > 256 ||
+            /[\u0000-\u001f\u007f]/.test(configuration.namespace)) {
+            throw new Error("Runtime namespace must contain 1 to 256 characters");
+        }
+        for (const name of [
+            "maxCommandBytes",
+            "maxStateBytes",
+            "maxEventBytes",
+            "maxEventsPerTurn",
+            "maxOutboxCallsPerTurn",
+            "maxTimerChangesPerTurn",
+        ]) {
+            if (!Number.isSafeInteger(configuration[name]) || configuration[name] < 1)
+                throw new Error(`Invalid runtime limit: ${name}`);
+        }
+        const turn = Duration.toMillis(Duration.fromInputUnsafe(configuration.maxTurnDuration));
+        const lease = Duration.toMillis(Duration.fromInputUnsafe(configuration.actorLeaseDuration));
+        const renew = Duration.toMillis(Duration.fromInputUnsafe(configuration.actorLeaseRenewEvery));
+        if (![turn, lease, renew].every((value) => Number.isFinite(value) && value > 0) ||
+            renew >= lease / 2) {
+            throw new Error("Runtime durations must be positive and renewal must be shorter than half the lease");
+        }
+        return Object.freeze({ ...configuration });
+    },
+    catch: (cause) => new RegistrationError({
+        message: cause instanceof Error ? cause.message : "Invalid runtime configuration",
+    }),
+});

package/dist/runtime/dispatchers/layer.d.ts

@@ -0,0 +1,6 @@
+import { Layer } from "effect";
+import { Client } from "../../client/service.js";
+import { type StoreError } from "../../errors/index.js";
+import { Store } from "../../store/service.js";
+import { Runtime, type DispatchOptions } from "../service.js";
+export declare const layerDispatchers: (options: DispatchOptions) => Layer.Layer<never, StoreError, Runtime | Client | Store>;

package/dist/runtime/dispatchers/layer.js

@@ -0,0 +1,53 @@
+import { Duration, Effect, Layer } from "effect";
+import { Client } from "../../client/service.js";
+import { InvalidInput } from "../../errors/index.js";
+import { Store } from "../../store/service.js";
+import { Runtime } from "../service.js";
+import { deliver } from "./outbox.js";
+export const layerDispatchers = (options) => Layer.effectDiscard(Effect.gen(function* () {
+    yield* Effect.try({
+        try: () => {
+            if (!Number.isSafeInteger(options.batchSize) ||
+                options.batchSize < 1 ||
+                options.batchSize > 1000 ||
+                !Number.isSafeInteger(options.concurrency) ||
+                options.concurrency < 1 ||
+                options.concurrency > options.batchSize ||
+                ![options.pollInterval, options.claimDuration].every((input) => {
+                    const millis = Duration.toMillis(Duration.fromInputUnsafe(input));
+                    return Number.isFinite(millis) && millis > 0;
+                }))
+                throw new Error("Invalid dispatcher configuration");
+        },
+        catch: () => new InvalidInput({ message: "Invalid dispatcher configuration" }),
+    });
+    const runtime = yield* Runtime;
+    const store = yield* Store;
+    const client = yield* Client;
+    const namespace = runtime.configuration.namespace;
+    const outbox = Effect.gen(function* () {
+        const claims = yield* store.claimOutbox({
+            namespace,
+            limit: options.batchSize,
+            claimDuration: options.claimDuration,
+        });
+        yield* Effect.forEach(claims, (claim) => deliver(store, client, claim), {
+            concurrency: options.concurrency,
+            discard: true,
+        });
+    });
+    const timers = Effect.gen(function* () {
+        const due = yield* store.dueTimers({ namespace, limit: options.batchSize });
+        yield* Effect.forEach(due, (candidate) => runtime.wake(candidate), {
+            concurrency: options.concurrency,
+            discard: true,
+        });
+    });
+    const passes = [
+        ["outbox", outbox],
+        ["timers", timers],
+    ];
+    for (const [name, pass] of passes) {
+        yield* pass.pipe(Effect.catch((error) => Effect.logWarning("Actor dispatcher pass failed").pipe(Effect.annotateLogs({ dispatcher: name, errorCode: error._tag }))), Effect.andThen(Effect.sleep(options.pollInterval)), Effect.forever, Effect.forkScoped);
+    }
+}));

package/dist/runtime/dispatchers/outbox.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import type { Client } from "../../client/service.js";
+import type { OutboxClaim, Store } from "../../store/service.js";
+export declare const deliver: (store: Store["Service"], client: Client["Service"], claim: OutboxClaim) => Effect.Effect<void, import("../../errors/index.js").StoreError, never>;

package/dist/runtime/dispatchers/outbox.js

@@ -0,0 +1,57 @@
+import { Clock, Effect, Result } from "effect";
+import { FrameworkErrorSchema, } from "../../errors/index.js";
+import { fingerprint } from "../../protocol/encoding.js";
+import { encodeJson } from "../../actor/state/codec.js";
+const retryable = (error) => {
+    switch (error._tag) {
+        case "effect-actors/OwnershipLost":
+        case "effect-actors/Overloaded":
+        case "effect-actors/OutcomeUnknown":
+            return true;
+        case "effect-actors/StorageUnavailable":
+        case "effect-actors/HostUnavailable":
+            return error.retryable;
+        default:
+            return false;
+    }
+};
+export const deliver = (store, client, claim) => Effect.gen(function* () {
+    const call = claim.command;
+    const digest = fingerprint({
+        command: call.operation,
+        protocolVersion: call.protocolVersion,
+        payload: call.payload,
+    });
+    const send = call.kind === "command"
+        ? client
+            .command({
+            address: call.target,
+            command: call.operation,
+            protocolVersion: call.protocolVersion,
+            payload: call.payload,
+            commandId: call.commandId,
+            fingerprint: digest,
+        })
+            .pipe(Effect.map((receipt) => receipt.value))
+        : client.hosted({
+            address: call.target,
+            action: call.operation,
+            protocolVersion: call.protocolVersion,
+            payload: call.payload,
+            requestKey: call.commandId,
+            fingerprint: digest,
+        });
+    const result = yield* Effect.result(send);
+    if (Result.isSuccess(result))
+        return yield* store.settleOutbox(claim, result.success);
+    if (!retryable(result.failure))
+        return yield* store.settleOutbox(claim, {
+            _tag: "Failure",
+            error: encodeJson(FrameworkErrorSchema, result.failure),
+        });
+    const now = yield* Clock.currentTimeMillis;
+    yield* store.retryOutbox(claim, {
+        retryAtMillis: now + Math.min(60_000, 100 * 2 ** Math.min(claim.attempt, 10)),
+        reasonCode: result.failure._tag,
+    });
+});

package/dist/runtime/layer.d.ts

@@ -0,0 +1,6 @@
+import { Layer } from "effect";
+import { MessageStorage, Sharding } from "effect/unstable/cluster";
+import { Client } from "../client/service.js";
+import { RegistrationError } from "../errors/index.js";
+import { Runtime, type Configuration } from "./service.js";
+export declare const layer: (options: Configuration) => Layer.Layer<Runtime | Client, RegistrationError, Sharding.Sharding | MessageStorage.MessageStorage>;

package/dist/runtime/layer.js

@@ -0,0 +1,43 @@
+import { Context, Effect, Layer } from "effect";
+import { MessageStorage, Sharding } from "effect/unstable/cluster";
+import { Client } from "../client/service.js";
+import { RegistrationError } from "../errors/index.js";
+import { assertIdentifier } from "../actor/state/codec.js";
+import { make } from "./cluster/client.js";
+import { validate } from "./configuration.js";
+import { Runtime } from "./service.js";
+export const layer = (options) => Layer.effectContext(Effect.gen(function* () {
+    const configuration = yield* validate(options);
+    const sharding = yield* Sharding.Sharding;
+    const storage = yield* MessageStorage.MessageStorage;
+    if (storage === MessageStorage.noop)
+        return yield* new RegistrationError({
+            message: "Actor runtimes require Cluster message storage",
+        });
+    const registered = new Set();
+    const clients = make(configuration, sharding);
+    const runtime = {
+        configuration,
+        wake: clients.wake,
+        register: (registration) => Effect.gen(function* () {
+            yield* Effect.try({
+                try: () => {
+                    assertIdentifier(registration.actorType);
+                    if (!Number.isSafeInteger(registration.protocolVersion) ||
+                        registration.protocolVersion < 1) {
+                        throw new RegistrationError({ message: "Invalid actor protocol version" });
+                    }
+                    if (registered.has(registration.actorType))
+                        throw new RegistrationError({ message: "Actor type is already registered" });
+                    registered.add(registration.actorType);
+                },
+                catch: () => new RegistrationError({ message: "Invalid or duplicate actor registration" }),
+            });
+            yield* Effect.addFinalizer(() => Effect.sync(() => {
+                registered.delete(registration.actorType);
+            }));
+            yield* Layer.build(registration.entity).pipe(Effect.provideService(Sharding.Sharding, sharding));
+        }),
+    };
+    return Context.make(Runtime, runtime).pipe(Context.add(Client, clients.client));
+}));

package/dist/runtime/service.d.ts

@@ -0,0 +1,40 @@
+import { Context } from "effect";
+import type { Duration, Effect, Layer, Option, Scope } from "effect";
+import type { Sharding } from "effect/unstable/cluster";
+import type { CommandError, RegistrationError } from "../errors/index.js";
+import type { TimerCandidate } from "../store/service.js";
+import type { WireReceipt } from "../protocol/index.js";
+export interface Configuration {
+    readonly namespace: string;
+    readonly maxCommandBytes: number;
+    readonly maxStateBytes: number;
+    readonly maxEventBytes: number;
+    readonly maxEventsPerTurn: number;
+    readonly maxOutboxCallsPerTurn: number;
+    readonly maxTimerChangesPerTurn: number;
+    readonly maxTurnDuration: Duration.Input;
+    readonly actorLeaseDuration: Duration.Input;
+    readonly actorLeaseRenewEvery: Duration.Input;
+}
+export interface Registration {
+    readonly actorType: string;
+    readonly protocolVersion: number;
+    readonly kind: "state" | "hosted";
+    readonly entity: Layer.Layer<never, never, Sharding.Sharding>;
+}
+export interface Service {
+    readonly configuration: Configuration;
+    readonly wake: (candidate: TimerCandidate) => Effect.Effect<Option.Option<WireReceipt>, CommandError>;
+    readonly register: (registration: Registration) => Effect.Effect<void, RegistrationError, Scope.Scope>;
+}
+declare const Runtime_base: Context.ServiceClass<Runtime, "effect-actors/Runtime", Service>;
+export declare class Runtime extends Runtime_base {
+}
+export { layer } from "./layer.js";
+export interface DispatchOptions {
+    readonly pollInterval: Duration.Input;
+    readonly batchSize: number;
+    readonly concurrency: number;
+    readonly claimDuration: Duration.Input;
+}
+export { layerDispatchers } from "./dispatchers/layer.js";

package/dist/runtime/service.js

@@ -0,0 +1,5 @@
+import { Context } from "effect";
+export class Runtime extends Context.Service()("effect-actors/Runtime") {
+}
+export { layer } from "./layer.js";
+export { layerDispatchers } from "./dispatchers/layer.js";

package/dist/store/memory/background.d.ts

@@ -0,0 +1,39 @@
+import { Effect, Option, Result } from "effect";
+import { CursorExpired, InvalidInput, type StoreError } from "../../errors/index.js";
+import type { Address, Json, Outcome, WireReceipt } from "../../protocol/index.js";
+import type { EncodedTransition, OutboxClaim, Ownership, TimerCandidate, Turn } from "../service.js";
+import { type MemoryContext } from "./model.js";
+export declare const receipt: (context: MemoryContext, address: Address, commandId: string) => Effect.Effect<Option.Option<WireReceipt>, StoreError>;
+export declare const events: (context: MemoryContext, address: Address, options: {
+    readonly after: string;
+    readonly limit: number;
+}) => Effect.Effect<{
+    events: {
+        cursor: string;
+        commandId: string;
+        committedAtMillis: number;
+        value: import("effect/Schema").Json;
+    }[];
+    nextCursor: string;
+    hasMore: boolean;
+}, CursorExpired | InvalidInput, never>;
+export declare const claimOutbox: (context: MemoryContext, options: {
+    readonly namespace: string;
+    readonly limit: number;
+    readonly claimDuration: import("effect").Duration.Input;
+}) => Effect.Effect<ReadonlyArray<OutboxClaim>, StoreError>;
+export declare const settleOutbox: (context: MemoryContext, claim: OutboxClaim, outcome: Outcome) => Effect.Effect<void, StoreError>;
+export declare const retryOutbox: (context: MemoryContext, claim: OutboxClaim, options: {
+    readonly retryAtMillis: number;
+    readonly reasonCode: string;
+}) => Effect.Effect<void, StoreError>;
+export declare const dueTimers: (context: MemoryContext, options: {
+    readonly namespace: string;
+    readonly limit: number;
+}) => Effect.Effect<ReadonlyArray<TimerCandidate>, StoreError>;
+export declare const fireTimer: (context: MemoryContext, ownership: Ownership, candidate: TimerCandidate, evaluate: (command: string, payload: Json, turn: Turn) => Result.Result<EncodedTransition, Json>) => Effect.Effect<Option.Option<WireReceipt>, StoreError>;
+export declare const collectEvents: (context: MemoryContext, options: {
+    readonly namespace: string;
+    readonly beforeMillis: number;
+    readonly limit: number;
+}) => Effect.Effect<number, StoreError>;

package/dist/store/memory/background.js

@@ -0,0 +1,206 @@
+import { Clock, Effect, Option, Result } from "effect";
+import { CursorExpired, InvalidInput } from "../../errors/index.js";
+import { addressId, canonicalJson, makeCursor, readCursor, validateId, } from "../../protocol/index.js";
+import { decimalInput, normalizeCallbackError, nonNegativeInteger, positiveInteger, protocolBoundary, } from "../sql/model.js";
+import { timerCommandIdentity, timerFingerprint } from "../sql/transition.js";
+import { applyEvaluation, cloneJson, cloneReceipt, durationMillis, snapshot, } from "./model.js";
+import { withOwner } from "./ownership.js";
+export const receipt = (context, address, commandId) => protocolBoundary(() => {
+    validateId(commandId, 1024);
+    const stored = context.receipts.get(addressId(address))?.get(commandId);
+    return stored === undefined ? Option.none() : Option.some(cloneReceipt(stored.receipt));
+});
+export const events = (context, address, options) => Effect.gen(function* () {
+    const actorId = yield* protocolBoundary(() => addressId(address));
+    const after = yield* protocolBoundary(() => readCursor(address, options.after));
+    const limit = yield* protocolBoundary(() => positiveInteger(options.limit, "event page limit"));
+    return yield* context.gate.withPermit(Effect.gen(function* () {
+        const head = context.heads.get(actorId);
+        const highwater = head?.eventSequence ?? 0n;
+        const floor = head?.eventFloor ?? 0n;
+        if (BigInt(after) < floor) {
+            return yield* Effect.fail(new CursorExpired({ message: "Event cursor precedes retained history" }));
+        }
+        if (BigInt(after) > highwater) {
+            return yield* Effect.fail(new InvalidInput({ message: "Event cursor is ahead of the actor" }));
+        }
+        const selected = (context.events.get(actorId) ?? [])
+            .filter((event) => event.sequence > BigInt(after))
+            .slice(0, limit + 1);
+        const page = selected.slice(0, limit);
+        return {
+            events: page.map(({ sequence: _, ...event }) => ({
+                ...event,
+                value: cloneJson(event.value),
+            })),
+            nextCursor: makeCursor(address, page.at(-1)?.sequence.toString() ?? after),
+            hasMore: selected.length > limit,
+        };
+    }));
+});
+export const claimOutbox = (context, options) => Effect.gen(function* () {
+    const limit = yield* protocolBoundary(() => positiveInteger(options.limit, "outbox claim limit"));
+    const duration = yield* durationMillis(options.claimDuration, "claimDuration");
+    if (typeof options.namespace !== "string" || options.namespace.length === 0) {
+        return yield* Effect.fail(new InvalidInput({ message: "Invalid outbox namespace" }));
+    }
+    return yield* context.gate.withPermit(Effect.gen(function* () {
+        const nowMillis = yield* Clock.currentTimeMillis;
+        return [...context.outbox.values()]
+            .filter((call) => call.namespace === options.namespace &&
+            ((call.status === "pending" && call.retryAtMillis <= nowMillis) ||
+                (call.status === "claimed" && call.claimUntilMillis <= nowMillis)))
+            .sort((left, right) => left.createdAtMillis - right.createdAtMillis || left.id.localeCompare(right.id))
+            .slice(0, limit)
+            .map((call) => {
+            const claimToken = `memory-${++context.token}`;
+            call.status = "claimed";
+            call.attempt += 1;
+            call.claimToken = claimToken;
+            call.claimUntilMillis = nowMillis + duration;
+            return {
+                id: call.id,
+                claimToken,
+                attempt: call.attempt,
+                command: cloneJson(call.command),
+            };
+        });
+    }));
+});
+const validateClaim = (claim) => protocolBoundary(() => {
+    if (typeof claim.id !== "string" ||
+        claim.id.length === 0 ||
+        typeof claim.claimToken !== "string" ||
+        claim.claimToken.length === 0) {
+        throw new InvalidInput({ message: "Invalid outbox claim" });
+    }
+});
+export const settleOutbox = (context, claim, outcome) => Effect.gen(function* () {
+    yield* validateClaim(claim);
+    const encoded = yield* protocolBoundary(() => cloneJson(outcome));
+    yield* context.gate.withPermit(Effect.gen(function* () {
+        const nowMillis = yield* Clock.currentTimeMillis;
+        const call = context.outbox.get(claim.id);
+        if (call === undefined ||
+            call.status !== "claimed" ||
+            call.claimToken !== claim.claimToken ||
+            call.claimUntilMillis <= nowMillis)
+            return;
+        call.status = "settled";
+        call.outcome = encoded;
+        call.claimToken = undefined;
+        call.claimUntilMillis = undefined;
+        call.reasonCode = undefined;
+    }));
+});
+export const retryOutbox = (context, claim, options) => Effect.gen(function* () {
+    yield* validateClaim(claim);
+    yield* protocolBoundary(() => {
+        nonNegativeInteger(options.retryAtMillis, "retryAtMillis");
+        if (typeof options.reasonCode !== "string" ||
+            options.reasonCode.length === 0 ||
+            options.reasonCode.length > 256) {
+            throw new InvalidInput({ message: "Invalid outbox retry reason" });
+        }
+    });
+    yield* context.gate.withPermit(Effect.gen(function* () {
+        const nowMillis = yield* Clock.currentTimeMillis;
+        const call = context.outbox.get(claim.id);
+        if (call === undefined ||
+            call.status !== "claimed" ||
+            call.claimToken !== claim.claimToken ||
+            call.claimUntilMillis <= nowMillis)
+            return;
+        call.status = "pending";
+        call.retryAtMillis = options.retryAtMillis;
+        call.reasonCode = options.reasonCode;
+        call.claimToken = undefined;
+        call.claimUntilMillis = undefined;
+    }));
+});
+export const dueTimers = (context, options) => Effect.gen(function* () {
+    const limit = yield* protocolBoundary(() => positiveInteger(options.limit, "timer scan limit"));
+    if (typeof options.namespace !== "string" || options.namespace.length === 0) {
+        return yield* Effect.fail(new InvalidInput({ message: "Invalid timer namespace" }));
+    }
+    return yield* context.gate.withPermit(Effect.gen(function* () {
+        const nowMillis = yield* Clock.currentTimeMillis;
+        return [...context.timers.values()]
+            .filter((timer) => timer.address.namespace === options.namespace &&
+            timer.status === "scheduled" &&
+            timer.dueAtMillis <= nowMillis)
+            .sort((left, right) => left.dueAtMillis - right.dueAtMillis)
+            .slice(0, limit)
+            .map((timer) => ({
+            address: timer.address,
+            timerId: timer.timerId,
+            generation: timer.generation.toString(),
+            dueAtMillis: timer.dueAtMillis,
+        }));
+    }));
+});
+export const fireTimer = (context, ownership, candidate, evaluate) => withOwner(context, ownership, (owner, head, nowMillis) => Effect.gen(function* () {
+    const candidateAddress = yield* protocolBoundary(() => addressId(candidate.address));
+    if (candidateAddress !== owner.addressId) {
+        return yield* Effect.fail(new InvalidInput({ message: "Timer candidate does not match its owner" }));
+    }
+    yield* protocolBoundary(() => {
+        validateId(candidate.timerId);
+        decimalInput(candidate.generation, "timer generation");
+        nonNegativeInteger(candidate.dueAtMillis, "timer dueAtMillis");
+    });
+    const timer = context.timers.get(canonicalJson([owner.addressId, candidate.timerId]));
+    if (timer === undefined ||
+        timer.status !== "scheduled" ||
+        timer.generation.toString() !== candidate.generation ||
+        timer.dueAtMillis !== candidate.dueAtMillis ||
+        timer.dueAtMillis > nowMillis)
+        return Option.none();
+    const current = yield* Effect.try({
+        try: () => snapshot(head),
+        catch: normalizeCallbackError,
+    });
+    const evaluation = yield* Effect.try({
+        try: () => evaluate(timer.command, cloneJson(timer.payload), { snapshot: current, nowMillis }),
+        catch: normalizeCallbackError,
+    });
+    const result = yield* applyEvaluation(context, head, {
+        commandId: timerCommandIdentity(timer.timerId, timer.generation.toString()),
+        fingerprint: timerFingerprint(timer.timerId, timer.generation.toString(), timer.command, timer.payload),
+        evaluation,
+        consume: () => {
+            timer.status = "consumed";
+        },
+    });
+    return Option.some(result);
+}));
+export const collectEvents = (context, options) => protocolBoundary(() => {
+    positiveInteger(options.limit, "event retention limit");
+    nonNegativeInteger(options.beforeMillis, "event retention cutoff");
+    if (typeof options.namespace !== "string" || options.namespace.length === 0) {
+        throw new InvalidInput({ message: "Invalid event retention namespace" });
+    }
+}).pipe(Effect.flatMap(() => context.gate.withPermit(Effect.sync(() => {
+    const candidates = [...context.events.entries()]
+        .flatMap(([actorId, actorEvents]) => actorEvents.map((event) => ({ actorId, event })))
+        .filter(({ event }) => event.committedAtMillis < options.beforeMillis)
+        .filter(({ actorId }) => context.heads.get(actorId)?.address.namespace === options.namespace)
+        .sort((left, right) => left.event.committedAtMillis - right.event.committedAtMillis ||
+        left.actorId.localeCompare(right.actorId) ||
+        (left.event.sequence < right.event.sequence
+            ? -1
+            : left.event.sequence > right.event.sequence
+                ? 1
+                : 0))
+        .slice(0, options.limit);
+    for (const { actorId, event } of candidates) {
+        const actorEvents = context.events.get(actorId);
+        const index = actorEvents.indexOf(event);
+        if (index >= 0)
+            actorEvents.splice(index, 1);
+        const head = context.heads.get(actorId);
+        if (head !== undefined && head.eventFloor < event.sequence)
+            head.eventFloor = event.sequence;
+    }
+    return candidates.length;
+}))));

package/dist/store/memory/model.d.ts

@@ -0,0 +1,72 @@
+import { Duration, Effect, Result } from "effect";
+import type { Deferred, Semaphore } from "effect";
+import { InvalidInput, type StoreError } from "../../errors/index.js";
+import type { Address, Event, Json, Outcome, OutgoingCommand, WireReceipt } from "../../protocol/index.js";
+import type { EncodedTransition, Ownership, Snapshot } from "../service.js";
+export interface MemoryHead {
+    readonly address: Address;
+    fence: bigint;
+    leaseUntil: number;
+    schemaVersion?: number;
+    state?: Json;
+    revision: bigint;
+    eventSequence: bigint;
+    eventFloor: bigint;
+}
+export interface MemoryReceipt {
+    readonly fingerprint: string;
+    readonly receipt: WireReceipt;
+}
+export interface MemoryTimer {
+    readonly address: Address;
+    readonly timerId: string;
+    generation: bigint;
+    status: "scheduled" | "cancelled" | "consumed";
+    dueAtMillis?: number;
+    command?: string;
+    payload?: Json;
+}
+export interface MemoryOutbox {
+    readonly id: string;
+    readonly namespace: string;
+    readonly command: OutgoingCommand;
+    readonly createdAtMillis: number;
+    status: "pending" | "claimed" | "settled";
+    attempt: number;
+    retryAtMillis: number;
+    claimToken?: string;
+    claimUntilMillis?: number;
+    outcome?: Outcome;
+    reasonCode?: string;
+}
+export interface MemoryOwner {
+    readonly addressId: string;
+    readonly address: Address;
+    readonly fence: string;
+    readonly lost: Deferred.Deferred<never, StoreError>;
+    active: boolean;
+}
+export interface MemoryContext {
+    readonly gate: Semaphore.Semaphore;
+    readonly heads: Map<string, MemoryHead>;
+    readonly receipts: Map<string, Map<string, MemoryReceipt>>;
+    readonly events: Map<string, Array<Event<Json> & {
+        readonly sequence: bigint;
+    }>>;
+    readonly timers: Map<string, MemoryTimer>;
+    readonly outbox: Map<string, MemoryOutbox>;
+    readonly owners: WeakMap<Ownership, MemoryOwner>;
+    token: bigint;
+}
+export declare const cloneJson: <A extends Json>(value: A) => A;
+export declare const durationMillis: (input: Duration.Input, name: string) => Effect.Effect<number, InvalidInput>;
+export declare const snapshot: (head: MemoryHead) => Snapshot;
+export declare const receiptValue: (address: Address, commandId: string, revision: bigint, sequence: bigint, committedAtMillis: number, outcome: Outcome) => WireReceipt;
+export declare const cloneReceipt: (receipt: WireReceipt) => WireReceipt;
+export declare const receiptMap: (context: MemoryContext, actorId: string) => Map<string, MemoryReceipt>;
+export declare const applyEvaluation: (context: MemoryContext, head: MemoryHead, input: {
+    readonly commandId: string;
+    readonly fingerprint: string;
+    readonly evaluation: Result.Result<EncodedTransition, Json>;
+    readonly consume?: () => void;
+}) => Effect.Effect<WireReceipt, StoreError>;