effect-actors 0.0.1

package/dist/store/sql/schema.js

@@ -0,0 +1,124 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { InvalidInput, UnsupportedVersion } from "../../errors/index.js";
+import { dialectOf, integer, normalizeSqlError, protectSql, protocolBoundary, validateTablePrefix, } from "./model.js";
+export const schemaVersion = 1;
+const migrationStatements = (tables) => [
+    `CREATE TABLE IF NOT EXISTS ${tables.heads} (
+    address TEXT PRIMARY KEY,
+    address_json TEXT NOT NULL,
+    namespace TEXT NOT NULL,
+    fence BIGINT NOT NULL DEFAULT 0 CHECK (fence >= 0),
+    lease_until_ms BIGINT NOT NULL DEFAULT 0,
+    schema_version INTEGER,
+    state TEXT,
+    revision BIGINT NOT NULL DEFAULT 0 CHECK (revision >= 0),
+    event_sequence BIGINT NOT NULL DEFAULT 0 CHECK (event_sequence >= 0),
+    event_floor BIGINT NOT NULL DEFAULT 0 CHECK (event_floor >= 0 AND event_floor <= event_sequence),
+    CHECK ((schema_version IS NULL AND state IS NULL) OR (schema_version IS NOT NULL AND state IS NOT NULL))
+  )`,
+    `CREATE INDEX IF NOT EXISTS ${tables.heads}_namespace_idx ON ${tables.heads} (namespace, address)`,
+    `CREATE TABLE IF NOT EXISTS ${tables.receipts} (
+    address TEXT NOT NULL,
+    command_id TEXT NOT NULL,
+    fingerprint TEXT NOT NULL,
+    outcome TEXT NOT NULL,
+    revision BIGINT NOT NULL CHECK (revision >= 0),
+    event_sequence BIGINT NOT NULL CHECK (event_sequence >= 0),
+    committed_at_ms BIGINT NOT NULL,
+    PRIMARY KEY (address, command_id),
+    FOREIGN KEY (address) REFERENCES ${tables.heads} (address) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS ${tables.events} (
+    address TEXT NOT NULL,
+    namespace TEXT NOT NULL,
+    sequence BIGINT NOT NULL CHECK (sequence > 0),
+    command_id TEXT NOT NULL,
+    payload TEXT NOT NULL,
+    committed_at_ms BIGINT NOT NULL,
+    PRIMARY KEY (address, sequence),
+    FOREIGN KEY (address) REFERENCES ${tables.heads} (address) ON DELETE CASCADE
+  )`,
+    `CREATE INDEX IF NOT EXISTS ${tables.events}_retention_idx ON ${tables.events} (namespace, committed_at_ms, address, sequence)`,
+    `CREATE TABLE IF NOT EXISTS ${tables.timers} (
+    address TEXT NOT NULL,
+    address_json TEXT NOT NULL,
+    namespace TEXT NOT NULL,
+    timer_id TEXT NOT NULL,
+    generation BIGINT NOT NULL CHECK (generation > 0),
+    status TEXT NOT NULL CHECK (status IN ('scheduled', 'cancelled', 'consumed')),
+    due_at_ms BIGINT,
+    command_name TEXT,
+    payload TEXT,
+    PRIMARY KEY (address, timer_id),
+    FOREIGN KEY (address) REFERENCES ${tables.heads} (address) ON DELETE CASCADE
+  )`,
+    `CREATE INDEX IF NOT EXISTS ${tables.timers}_due_idx ON ${tables.timers} (namespace, status, due_at_ms, address, timer_id)`,
+    `CREATE TABLE IF NOT EXISTS ${tables.outbox} (
+    delivery_id TEXT PRIMARY KEY,
+    source_address TEXT NOT NULL,
+    namespace TEXT NOT NULL,
+    source_command_id TEXT NOT NULL,
+    target_call TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('pending', 'claimed', 'settled')),
+    attempt INTEGER NOT NULL DEFAULT 0 CHECK (attempt >= 0),
+    claim_token TEXT,
+    claim_until_ms BIGINT,
+    retry_at_ms BIGINT NOT NULL DEFAULT 0,
+    outcome TEXT,
+    reason_code TEXT,
+    created_at_ms BIGINT NOT NULL,
+    FOREIGN KEY (source_address) REFERENCES ${tables.heads} (address) ON DELETE CASCADE
+  )`,
+    `CREATE INDEX IF NOT EXISTS ${tables.outbox}_claim_idx ON ${tables.outbox} (namespace, status, retry_at_ms, claim_until_ms, created_at_ms, delivery_id)`,
+];
+export const validateSchema = (sql, tables) => Effect.gen(function* () {
+    const versions = yield* sql.unsafe(`SELECT version FROM ${tables.schema} WHERE id = 1`);
+    if (versions.length !== 1)
+        throw new Error("Missing actor store schema version");
+    const version = integer(versions[0].version);
+    if (version !== schemaVersion) {
+        return yield* Effect.fail(new UnsupportedVersion({
+            actorType: "effect-actors/store",
+            version,
+        }));
+    }
+    yield* sql.unsafe(`SELECT address, address_json, namespace, fence, lease_until_ms, schema_version, state, revision, event_sequence, event_floor FROM ${tables.heads} WHERE 1 = 0`);
+    yield* sql.unsafe(`SELECT address, command_id, fingerprint, outcome, revision, event_sequence, committed_at_ms FROM ${tables.receipts} WHERE 1 = 0`);
+    yield* sql.unsafe(`SELECT address, namespace, sequence, command_id, payload, committed_at_ms FROM ${tables.events} WHERE 1 = 0`);
+    yield* sql.unsafe(`SELECT address, address_json, namespace, timer_id, generation, status, due_at_ms, command_name, payload FROM ${tables.timers} WHERE 1 = 0`);
+    yield* sql.unsafe(`SELECT delivery_id, source_address, namespace, source_command_id, target_call, status, attempt, claim_token, claim_until_ms, retry_at_ms, outcome, reason_code, created_at_ms FROM ${tables.outbox} WHERE 1 = 0`);
+})
+    .pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(normalizeSqlError(undefined))))
+    .pipe(Effect.provideService(SqlClient.SafeIntegers, true));
+export const migrate = (options) => protectSql(Effect.gen(function* () {
+    const tables = yield* protocolBoundary(() => validateTablePrefix(options.tablePrefix));
+    const sql = yield* SqlClient.SqlClient;
+    const dialect = yield* protocolBoundary(() => dialectOf(sql));
+    yield* sql.withTransaction(Effect.gen(function* () {
+        yield* sql.unsafe(`CREATE TABLE IF NOT EXISTS ${tables.schema} (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        version INTEGER NOT NULL CHECK (version >= 0)
+      )`);
+        yield* sql.unsafe(`INSERT INTO ${tables.schema} (id, version) VALUES (1, 0) ON CONFLICT (id) DO NOTHING`);
+        const rows = yield* sql.unsafe(`SELECT version FROM ${tables.schema} WHERE id = 1${dialect === "pg" ? " FOR UPDATE" : ""}`);
+        if (rows.length !== 1)
+            throw new Error("Missing actor store schema version");
+        const current = integer(rows[0].version);
+        if (current > schemaVersion) {
+            return yield* Effect.fail(new UnsupportedVersion({
+                actorType: "effect-actors/store",
+                version: current,
+            }));
+        }
+        if (current < 0) {
+            return yield* Effect.fail(new InvalidInput({ message: "Invalid actor store schema version" }));
+        }
+        if (current === 0) {
+            for (const statement of migrationStatements(tables))
+                yield* sql.unsafe(statement);
+            yield* sql.unsafe(`UPDATE ${tables.schema} SET version = 1 WHERE id = 1 AND version = 0`);
+        }
+        yield* validateSchema(sql, tables);
+    }));
+}));

package/dist/store/sql/service.d.ts

@@ -0,0 +1,5 @@
+import { Crypto, Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { type StoreError } from "../../errors/index.js";
+import type { Service, SqlOptions } from "../service.js";
+export declare const make: (options: SqlOptions) => Effect.Effect<Service, StoreError, SqlClient.SqlClient | Crypto.Crypto>;

package/dist/store/sql/service.js

@@ -0,0 +1,42 @@
+import { Crypto, Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { StorageUnavailable } from "../../errors/index.js";
+import { collectEvents, events } from "./events.js";
+import { dialectOf, normalizeSqlError, protocolBoundary, validateTablePrefix } from "./model.js";
+import { acquire } from "./ownership.js";
+import { claimOutbox, retryOutbox, settleOutbox } from "./outbox.js";
+import { receipt } from "./receipts.js";
+import { validateSchema } from "./schema.js";
+import { initialize, query } from "./state.js";
+import { dueTimers, fireTimer } from "./timers.js";
+import { transact } from "./transaction.js";
+export const make = (options) => Effect.gen(function* () {
+    const tables = yield* protocolBoundary(() => validateTablePrefix(options.tablePrefix));
+    const sql = yield* SqlClient.SqlClient;
+    const crypto = yield* Crypto.Crypto;
+    const dialect = yield* protocolBoundary(() => dialectOf(sql));
+    yield* validateSchema(sql, tables);
+    const context = {
+        sql,
+        crypto,
+        dialect,
+        tables,
+        owners: new WeakMap(),
+    };
+    const safeIntegers = (effect) => Effect.provideService(effect, SqlClient.SafeIntegers, true);
+    const service = {
+        acquire: (address, acquireOptions) => safeIntegers(acquire(context, address, acquireOptions)),
+        initialize: (owner, initializeOptions) => safeIntegers(initialize(context, owner, initializeOptions)),
+        transact: (owner, input, evaluate) => safeIntegers(transact(context, owner, input, evaluate)),
+        query: (owner, evaluate) => safeIntegers(query(context, owner, evaluate)),
+        receipt: (address, commandId) => safeIntegers(receipt(context, address, commandId)),
+        events: (address, eventOptions) => safeIntegers(events(context, address, eventOptions)),
+        claimOutbox: (claimOptions) => safeIntegers(claimOutbox(context, claimOptions)),
+        settleOutbox: (claim, outcome) => safeIntegers(settleOutbox(context, claim, outcome)),
+        retryOutbox: (claim, retryOptions) => safeIntegers(retryOutbox(context, claim, retryOptions)),
+        dueTimers: (timerOptions) => safeIntegers(dueTimers(context, timerOptions)),
+        fireTimer: (owner, candidate, evaluate) => safeIntegers(fireTimer(context, owner, candidate, evaluate)),
+        collectEvents: (retentionOptions) => safeIntegers(collectEvents(context, retentionOptions)),
+    };
+    return service;
+}).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));

package/dist/store/sql/state.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { type StoreError } from "../../errors/index.js";
+import type { Json } from "../../protocol/index.js";
+import type { Migration } from "../../actor/definition.js";
+import type { Ownership, Snapshot } from "../service.js";
+import { type HeadRow, type OwnerState, type SqlStoreContext } from "./ownership.js";
+export declare const snapshotFromHead: (state: OwnerState, row: HeadRow) => Effect.Effect<Snapshot, StoreError>;
+export declare const initialize: (context: SqlStoreContext, owner: Ownership, options: {
+    readonly currentVersion: number;
+    readonly initial: Json;
+    readonly migrations: ReadonlyArray<Migration>;
+}) => Effect.Effect<Snapshot, StoreError>;
+export declare const query: <A>(context: SqlStoreContext, owner: Ownership, evaluate: (snapshot: Snapshot) => A) => Effect.Effect<A, StoreError>;

package/dist/store/sql/state.js

@@ -0,0 +1,109 @@
+import { Effect, Result } from "effect";
+import { MigrationRejected, OwnershipLost, StorageUnavailable, UnsupportedVersion, } from "../../errors/index.js";
+import { makeCursor } from "../../protocol/index.js";
+import { databaseNow, decimal, decodeJson, encodeJson, integer, normalizeCallbackError, normalizeSqlError, positiveInteger, protocolBoundary, } from "./model.js";
+import { finalFence, ownedHead, withOwner, } from "./ownership.js";
+const invalidStoredData = () => new StorageUnavailable({ retryable: false });
+export const snapshotFromHead = (state, row) => row.schema_version === null ||
+    row.schema_version === undefined ||
+    row.state === null ||
+    row.state === undefined
+    ? Effect.fail(new UnsupportedVersion({ actorType: state.address.actorType, version: 0 }))
+    : protocolBoundary(() => ({
+        schemaVersion: integer(row.schema_version),
+        state: decodeJson(row.state),
+        revision: decimal(row.revision),
+        cursor: makeCursor(state.address, decimal(row.event_sequence)),
+    })).pipe(Effect.mapError(() => invalidStoredData()));
+export const initialize = (context, owner, options) => withOwner(context, owner, (state) => {
+    const program = Effect.gen(function* () {
+        const currentVersion = yield* protocolBoundary(() => positiveInteger(options.currentVersion, "currentVersion"));
+        const initial = yield* protocolBoundary(() => encodeJson(options.initial));
+        const head = yield* ownedHead(context, state, true);
+        if (head.schema_version === null || head.schema_version === undefined) {
+            const updated = yield* context.sql `
+        UPDATE ${context.sql(context.tables.heads)}
+        SET schema_version = ${currentVersion}, state = ${initial}
+        WHERE address = ${state.addressId} AND fence = ${state.fence} AND schema_version IS NULL
+          AND lease_until_ms > ${databaseNow(context.sql, context.dialect)}
+        RETURNING schema_version
+      `;
+            if (updated.length !== 1)
+                return yield* Effect.fail(new OwnershipLost({ actorType: state.address.actorType }));
+            yield* finalFence(context, state);
+            return {
+                schemaVersion: currentVersion,
+                state: options.initial,
+                revision: decimal(head.revision),
+                cursor: yield* protocolBoundary(() => makeCursor(state.address, decimal(head.event_sequence))),
+            };
+        }
+        const storedVersion = integer(head.schema_version);
+        if (storedVersion > currentVersion) {
+            return yield* Effect.fail(new UnsupportedVersion({ actorType: state.address.actorType, version: storedVersion }));
+        }
+        if (storedVersion === currentVersion)
+            return yield* snapshotFromHead(state, head);
+        let version = storedVersion;
+        let encoded = decodeJson(head.state);
+        while (version < currentVersion) {
+            const candidates = options.migrations.filter((migration) => migration.fromVersion === version);
+            if (candidates.length !== 1) {
+                return yield* Effect.fail(new MigrationRejected({
+                    fromVersion: version,
+                    toVersion: currentVersion,
+                    message: "Migration chain is incomplete or ambiguous",
+                }));
+            }
+            const migration = candidates[0];
+            if (!Number.isSafeInteger(migration.toVersion) ||
+                migration.toVersion <= version ||
+                migration.toVersion > currentVersion) {
+                return yield* Effect.fail(new MigrationRejected({
+                    fromVersion: migration.fromVersion,
+                    toVersion: migration.toVersion,
+                    message: "Migration chain does not advance toward the current version",
+                }));
+            }
+            const result = yield* Effect.try({
+                try: () => migration.migrate(encoded),
+                catch: normalizeCallbackError,
+            });
+            if (Result.isFailure(result))
+                return yield* Effect.fail(result.failure);
+            encoded = result.success;
+            yield* protocolBoundary(() => encodeJson(encoded));
+            version = migration.toVersion;
+        }
+        const stored = yield* protocolBoundary(() => encodeJson(encoded));
+        const updated = yield* context.sql `
+      UPDATE ${context.sql(context.tables.heads)}
+      SET schema_version = ${currentVersion}, state = ${stored}
+      WHERE address = ${state.addressId} AND fence = ${state.fence} AND schema_version = ${storedVersion}
+        AND lease_until_ms > ${databaseNow(context.sql, context.dialect)}
+      RETURNING schema_version
+    `;
+        if (updated.length !== 1)
+            return yield* Effect.fail(new OwnershipLost({ actorType: state.address.actorType }));
+        yield* finalFence(context, state);
+        return {
+            schemaVersion: currentVersion,
+            state: encoded,
+            revision: decimal(head.revision),
+            cursor: yield* protocolBoundary(() => makeCursor(state.address, decimal(head.event_sequence))),
+        };
+    });
+    return context.sql.withTransaction(program).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));
+});
+export const query = (context, owner, evaluate) => withOwner(context, owner, (state) => {
+    const program = Effect.gen(function* () {
+        const snapshot = yield* ownedHead(context, state, true).pipe(Effect.flatMap((head) => snapshotFromHead(state, head)));
+        const value = yield* Effect.try({
+            try: () => evaluate(snapshot),
+            catch: normalizeCallbackError,
+        });
+        yield* ownedHead(context, state, false);
+        return value;
+    });
+    return context.sql.withTransaction(program).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));
+});

package/dist/store/sql/timers.d.ts

@@ -0,0 +1,10 @@
+import { Effect, Option, Result } from "effect";
+import { type StoreError } from "../../errors/index.js";
+import type { Json, WireReceipt } from "../../protocol/index.js";
+import type { EncodedTransition, Ownership, TimerCandidate, Turn } from "../service.js";
+import { type SqlStoreContext } from "./ownership.js";
+export declare const dueTimers: (context: SqlStoreContext, options: {
+    readonly namespace: string;
+    readonly limit: number;
+}) => Effect.Effect<ReadonlyArray<TimerCandidate>, StoreError>;
+export declare const fireTimer: (context: SqlStoreContext, owner: Ownership, candidate: TimerCandidate, evaluate: (command: string, payload: Json, turn: Turn) => Result.Result<EncodedTransition, Json>) => Effect.Effect<Option.Option<WireReceipt>, StoreError>;

package/dist/store/sql/timers.js

@@ -0,0 +1,90 @@
+import { Effect, Option, Result } from "effect";
+import { InvalidInput, StorageUnavailable } from "../../errors/index.js";
+import { addressId, validateId } from "../../protocol/index.js";
+import { databaseNow, decimal, decodeAddress, decodeJson, integer, normalizeCallbackError, normalizeSqlError, positiveInteger, protocolBoundary, } from "./model.js";
+import { ownedHead, withOwner } from "./ownership.js";
+import { snapshotFromHead } from "./state.js";
+import { applyEvaluation, timerCommandIdentity, timerFingerprint } from "./transition.js";
+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" }));
+    }
+    const { dialect, sql, tables } = context;
+    const rows = yield* sql `
+    SELECT address, address_json, timer_id, generation, due_at_ms
+    FROM ${sql(tables.timers)}
+    WHERE namespace = ${options.namespace}
+      AND status = 'scheduled'
+      AND due_at_ms <= ${databaseNow(sql, dialect)}
+    ORDER BY due_at_ms, address, timer_id
+    LIMIT ${limit}
+  `;
+    return yield* protocolBoundary(() => rows.map((row) => {
+        if (typeof row.address !== "string" || typeof row.timer_id !== "string")
+            throw new Error("Invalid timer row");
+        return {
+            address: decodeAddress(row.address_json, row.address),
+            timerId: row.timer_id,
+            generation: decimal(row.generation),
+            dueAtMillis: integer(row.due_at_ms),
+        };
+    })).pipe(Effect.mapError(() => new StorageUnavailable({ retryable: false })));
+}).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));
+export const fireTimer = (context, owner, candidate, evaluate) => withOwner(context, owner, (state) => {
+    const program = Effect.gen(function* () {
+        const candidateAddress = yield* protocolBoundary(() => addressId(candidate.address));
+        if (candidateAddress !== state.addressId) {
+            return yield* Effect.fail(new InvalidInput({ message: "Timer candidate does not match its owner" }));
+        }
+        yield* protocolBoundary(() => {
+            validateId(candidate.timerId);
+            decimal(candidate.generation);
+            if (!Number.isSafeInteger(candidate.dueAtMillis) || candidate.dueAtMillis < 0) {
+                throw new InvalidInput({ message: "Invalid timer candidate" });
+            }
+        });
+        const head = yield* ownedHead(context, state, true);
+        const snapshot = yield* snapshotFromHead(state, head);
+        const rows = yield* context.sql `
+      UPDATE ${context.sql(context.tables.timers)}
+      SET status = 'consumed'
+      WHERE address = ${state.addressId}
+        AND timer_id = ${candidate.timerId}
+        AND generation = ${candidate.generation}
+        AND due_at_ms = ${candidate.dueAtMillis}
+        AND status = 'scheduled'
+        AND due_at_ms <= ${databaseNow(context.sql, context.dialect)}
+      RETURNING command_name, payload
+    `;
+        if (rows.length === 0)
+            return Option.none();
+        const row = rows[0];
+        const decoded = yield* protocolBoundary(() => {
+            if (typeof row.command_name !== "string" ||
+                row.payload === null ||
+                row.payload === undefined) {
+                throw new Error("Invalid timer intention");
+            }
+            return { command: row.command_name, payload: decodeJson(row.payload) };
+        }).pipe(Effect.mapError(() => new StorageUnavailable({ retryable: false })));
+        const evaluation = yield* Effect.try({
+            try: () => evaluate(decoded.command, decoded.payload, {
+                snapshot,
+                nowMillis: integer(head.now_ms),
+            }),
+            catch: normalizeCallbackError,
+        });
+        const commandId = yield* protocolBoundary(() => timerCommandIdentity(candidate.timerId, candidate.generation));
+        const fingerprint = yield* protocolBoundary(() => timerFingerprint(candidate.timerId, candidate.generation, decoded.command, decoded.payload));
+        return Option.some(yield* applyEvaluation(context, state, {
+            commandId,
+            fingerprint,
+            snapshot,
+            schemaVersion: snapshot.schemaVersion,
+            eventSequence: decimal(head.event_sequence),
+            evaluation,
+        }));
+    });
+    return context.sql.withTransaction(program).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));
+});

package/dist/store/sql/transaction.d.ts

@@ -0,0 +1,6 @@
+import { Effect, Result } from "effect";
+import { CommandConflict, type StoreError } from "../../errors/index.js";
+import type { Invocation, Json, WireReceipt } from "../../protocol/index.js";
+import type { EncodedTransition, Ownership, Turn } from "../service.js";
+import { type SqlStoreContext } from "./ownership.js";
+export declare const transact: (context: SqlStoreContext, owner: Ownership, input: Invocation, evaluate: (turn: Turn) => Result.Result<EncodedTransition, Json>) => Effect.Effect<WireReceipt, StoreError | CommandConflict>;

package/dist/store/sql/transaction.js

@@ -0,0 +1,57 @@
+import { Effect, Result } from "effect";
+import { CommandConflict, InvalidInput, StorageUnavailable, } from "../../errors/index.js";
+import { addressId, validateId } from "../../protocol/index.js";
+import { decimal, decimalInput, integer, normalizeCallbackError, normalizeSqlError, protocolBoundary, } from "./model.js";
+import { ownedHead, withOwner } from "./ownership.js";
+import { recordFailure, storedReceipt } from "./receipts.js";
+import { snapshotFromHead } from "./state.js";
+import { applyEvaluation } from "./transition.js";
+export const transact = (context, owner, input, evaluate) => withOwner(context, owner, (state) => {
+    const program = Effect.gen(function* () {
+        const inputAddress = yield* protocolBoundary(() => addressId(input.address));
+        if (inputAddress !== state.addressId) {
+            return yield* Effect.fail(new InvalidInput({ message: "Invocation does not match its owner" }));
+        }
+        yield* protocolBoundary(() => validateId(input.commandId));
+        if (typeof input.fingerprint !== "string")
+            return yield* Effect.fail(new InvalidInput({ message: "Invalid command identity" }));
+        const head = yield* ownedHead(context, state, true);
+        const snapshot = yield* snapshotFromHead(state, head);
+        const duplicate = yield* storedReceipt(context, state, input.commandId);
+        if (duplicate !== undefined) {
+            if (duplicate.fingerprint !== input.fingerprint) {
+                return yield* Effect.fail(new CommandConflict({ commandId: input.commandId }));
+            }
+            return duplicate.receipt;
+        }
+        if (input.expectedRevision !== undefined) {
+            yield* protocolBoundary(() => decimalInput(input.expectedRevision, "expectedRevision"));
+            if (input.expectedRevision !== snapshot.revision) {
+                return yield* recordFailure(context, state, {
+                    commandId: input.commandId,
+                    fingerprint: input.fingerprint,
+                    error: {
+                        _tag: "effect-actors/RevisionConflict",
+                        expected: input.expectedRevision,
+                        actual: snapshot.revision,
+                    },
+                    revision: snapshot.revision,
+                    eventSequence: decimal(head.event_sequence),
+                });
+            }
+        }
+        const evaluation = yield* Effect.try({
+            try: () => evaluate({ snapshot, nowMillis: integer(head.now_ms) }),
+            catch: normalizeCallbackError,
+        });
+        return yield* applyEvaluation(context, state, {
+            commandId: input.commandId,
+            fingerprint: input.fingerprint,
+            snapshot,
+            schemaVersion: snapshot.schemaVersion,
+            eventSequence: decimal(head.event_sequence),
+            evaluation,
+        });
+    });
+    return context.sql.withTransaction(program).pipe(Effect.mapError(normalizeSqlError), Effect.catchDefect(() => Effect.fail(new StorageUnavailable({ retryable: true }))));
+});

package/dist/store/sql/transition.d.ts

@@ -0,0 +1,15 @@
+import { Effect, Result } from "effect";
+import { type StoreError } from "../../errors/index.js";
+import type { Json, WireReceipt } from "../../protocol/index.js";
+import type { EncodedTransition, Snapshot } from "../service.js";
+import { type OwnerState, type SqlStoreContext } from "./ownership.js";
+export declare const applyEvaluation: (context: SqlStoreContext, state: OwnerState, input: {
+    readonly commandId: string;
+    readonly fingerprint: string;
+    readonly snapshot: Snapshot;
+    readonly schemaVersion: number;
+    readonly eventSequence: string;
+    readonly evaluation: Result.Result<EncodedTransition, Json>;
+}) => Effect.Effect<WireReceipt, StoreError>;
+export declare const timerCommandIdentity: (timerId: string, generation: string) => string;
+export declare const timerFingerprint: (timerId: string, generation: string, command: string, payload: Json) => string;

package/dist/store/sql/transition.js

@@ -0,0 +1,154 @@
+import { Effect, Result } from "effect";
+import { InvalidInput, OwnershipLost, StorageUnavailable, } from "../../errors/index.js";
+import { addressId, canonicalJson, validateId } from "../../protocol/index.js";
+import { databaseNow, encodeJson, nonNegativeInteger, normalizeSqlError, protocolBoundary, } from "./model.js";
+import { finalFence } from "./ownership.js";
+import { committedAt, insertReceipt, recordFailure } from "./receipts.js";
+const prepareTransition = (source, transition) => protocolBoundary(() => {
+    const state = encodeJson(transition.state);
+    encodeJson(transition.value);
+    const events = transition.events.map((value) => ({ encoded: encodeJson(value) }));
+    const timers = transition.timers.map((change) => {
+        validateId(change.timerId);
+        if (change._tag === "Cancel")
+            return { _tag: "Cancel", timerId: change.timerId };
+        nonNegativeInteger(change.dueAtMillis, "timer dueAtMillis");
+        if (typeof change.command !== "string" ||
+            change.command.length === 0 ||
+            change.command.length > 256) {
+            throw new InvalidInput({ message: "Invalid timer command" });
+        }
+        return {
+            _tag: "Set",
+            timerId: change.timerId,
+            dueAtMillis: change.dueAtMillis,
+            command: change.command,
+            payload: encodeJson(change.payload),
+        };
+    });
+    const outbox = transition.outbox.map((call) => {
+        if (call.target.namespace !== source.namespace || call.target.tenant !== source.tenant) {
+            throw new InvalidInput({
+                message: "Outbox targets must remain in the source namespace and tenant",
+            });
+        }
+        addressId(call.target);
+        if ((call.kind !== "command" && call.kind !== "hosted") ||
+            typeof call.operation !== "string" ||
+            call.operation.length === 0 ||
+            !Number.isSafeInteger(call.protocolVersion) ||
+            call.protocolVersion < 0 ||
+            typeof call.commandId !== "string") {
+            throw new InvalidInput({ message: "Invalid outgoing command" });
+        }
+        validateId(call.commandId);
+        encodeJson(call.payload);
+        return {
+            targetCall: encodeJson(call),
+        };
+    });
+    return { state, value: transition.value, events, timers, outbox };
+});
+const applyTimers = (context, state, timers) => Effect.gen(function* () {
+    const { sql, tables } = context;
+    const addressJson = encodeJson(state.address);
+    for (const timer of timers) {
+        const updated = timer._tag === "Set"
+            ? yield* sql `
+        UPDATE ${sql(tables.timers)}
+        SET generation = generation + 1, status = 'scheduled', due_at_ms = ${timer.dueAtMillis},
+            command_name = ${timer.command}, payload = ${timer.payload}, address_json = ${addressJson},
+            namespace = ${state.address.namespace}
+        WHERE address = ${state.addressId} AND timer_id = ${timer.timerId}
+        RETURNING generation
+      `
+            : yield* sql `
+        UPDATE ${sql(tables.timers)}
+        SET generation = generation + 1, status = 'cancelled', due_at_ms = NULL,
+            command_name = NULL, payload = NULL, address_json = ${addressJson},
+            namespace = ${state.address.namespace}
+        WHERE address = ${state.addressId} AND timer_id = ${timer.timerId}
+        RETURNING generation
+      `;
+        if (updated.length > 0)
+            continue;
+        if (timer._tag === "Set") {
+            yield* sql `
+        INSERT INTO ${sql(tables.timers)}
+          (address, address_json, namespace, timer_id, generation, status, due_at_ms, command_name, payload)
+        VALUES (${state.addressId}, ${addressJson}, ${state.address.namespace}, ${timer.timerId}, 1,
+          'scheduled', ${timer.dueAtMillis}, ${timer.command}, ${timer.payload})
+      `;
+        }
+        else {
+            yield* sql `
+        INSERT INTO ${sql(tables.timers)}
+          (address, address_json, namespace, timer_id, generation, status)
+        VALUES (${state.addressId}, ${addressJson}, ${state.address.namespace}, ${timer.timerId}, 1, 'cancelled')
+      `;
+        }
+    }
+}).pipe(Effect.mapError(normalizeSqlError));
+const applyOutbox = (context, state, sourceCommandId, calls, nowMillis) => Effect.gen(function* () {
+    const { sql, tables } = context;
+    for (const call of calls) {
+        const deliveryId = yield* context.crypto.randomUUIDv4.pipe(Effect.mapError(() => new StorageUnavailable({ retryable: true })));
+        yield* sql `
+      INSERT INTO ${sql(tables.outbox)}
+        (delivery_id, source_address, namespace, source_command_id, target_call, status,
+          attempt, retry_at_ms, created_at_ms)
+      VALUES (${deliveryId}, ${state.addressId}, ${state.address.namespace}, ${sourceCommandId},
+        ${call.targetCall}, 'pending', 0, 0, ${nowMillis})
+    `;
+    }
+}).pipe(Effect.mapError(normalizeSqlError));
+export const applyEvaluation = (context, state, input) => Effect.gen(function* () {
+    const currentRevision = input.snapshot.revision;
+    const sequenceBefore = input.eventSequence;
+    if (Result.isFailure(input.evaluation)) {
+        return yield* recordFailure(context, state, {
+            commandId: input.commandId,
+            fingerprint: input.fingerprint,
+            error: input.evaluation.failure,
+            revision: currentRevision,
+            eventSequence: sequenceBefore,
+        });
+    }
+    const prepared = yield* prepareTransition(state.address, input.evaluation.success);
+    const nextRevision = (BigInt(currentRevision) + 1n).toString();
+    const nextSequence = (BigInt(sequenceBefore) + BigInt(prepared.events.length)).toString();
+    const nowMillis = yield* committedAt(context);
+    const updated = yield* context.sql `
+    UPDATE ${context.sql(context.tables.heads)}
+    SET state = ${prepared.state}, schema_version = ${input.schemaVersion}, revision = ${nextRevision},
+        event_sequence = ${nextSequence}
+    WHERE address = ${state.addressId} AND fence = ${state.fence} AND revision = ${currentRevision}
+      AND lease_until_ms > ${databaseNow(context.sql, context.dialect)}
+    RETURNING revision, event_sequence
+  `;
+    if (updated.length !== 1)
+        return yield* Effect.fail(new OwnershipLost({ actorType: state.address.actorType }));
+    for (let index = 0; index < prepared.events.length; index++) {
+        const sequence = (BigInt(sequenceBefore) + BigInt(index) + 1n).toString();
+        yield* context.sql `
+      INSERT INTO ${context.sql(context.tables.events)}
+        (address, namespace, sequence, command_id, payload, committed_at_ms)
+      VALUES (${state.addressId}, ${state.address.namespace}, ${sequence}, ${input.commandId},
+        ${prepared.events[index].encoded}, ${nowMillis})
+    `;
+    }
+    yield* applyTimers(context, state, prepared.timers);
+    yield* applyOutbox(context, state, input.commandId, prepared.outbox, nowMillis);
+    const receipt = yield* insertReceipt(context, state, {
+        commandId: input.commandId,
+        fingerprint: input.fingerprint,
+        outcome: { _tag: "Success", value: prepared.value },
+        revision: nextRevision,
+        eventSequence: nextSequence,
+        committedAtMillis: nowMillis,
+    });
+    yield* finalFence(context, state);
+    return receipt;
+}).pipe(Effect.mapError(normalizeSqlError));
+export const timerCommandIdentity = (timerId, generation) => `~effect-actors/timer/${canonicalJson([timerId, generation])}`;
+export const timerFingerprint = (timerId, generation, command, payload) => canonicalJson({ kind: "effect-actors/timer", timerId, generation, command, payload });

package/dist/testing/index.d.ts

@@ -0,0 +1,6 @@
+import { Layer } from "effect";
+import type { Client } from "../client/service.js";
+import { type Configuration, type Runtime } from "../runtime/service.js";
+import { type Store } from "../store/service.js";
+export declare const configuration: Configuration;
+export declare const layerMemory: Layer.Layer<Runtime | Client | Store>;