@akterjs/effect 0.0.0-stage → 0.1.0

package/dist/host/command/command-context.adapter.mjs

@@ -0,0 +1,90 @@
+import { StatementDetail } from "../../contract/hosted/handler-failure.pure.mjs";
+import { HandlerSql } from "../query/query-policy.pure.mjs";
+import { FileInputs, captureFileInputs, replayFileInputs } from "./files/command-file-inputs.sql.mjs";
+import { Array, Clock, Context, Effect, Layer, Option, Ref, Schema, Stream } from "effect";
+import { SecureRandom } from "effect/crypto";
+// src/host/command/command-context.adapter.ts
+const RecordedContext = Schema.Struct({
+	files: FileInputs,
+	ids: Schema.fromJsonString(Schema.Array(Schema.String)),
+	times: Schema.fromJsonString(Schema.Array(Schema.Int))
+});
+/** File storage is the engine's own: its writes to `akter_*` tables are not the handler's, even inside one. */
+const engineFiles = (files) => ({
+	attach: (attaching) => Effect.provideService(files.attach(attaching), HandlerSql, false),
+	available: Effect.provideService(files.available, HandlerSql, false),
+	fileUsage: (listing) => Effect.provideService(files.fileUsage(listing), HandlerSql, false),
+	list: (listing) => Effect.provideService(files.list(listing), HandlerSql, false),
+	read: (path, range) => Stream.provideService(files.read(path, range), HandlerSql, false),
+	remove: (path) => Effect.provideService(files.remove(path), HandlerSql, false)
+});
+const trackWith = (sources) => Effect.fnUntraced(function* track({ files, key, sql }) {
+	const { files: prepareFiles, id, now } = yield* sources;
+	const used = yield* Ref.make({
+		ids: [],
+		times: []
+	});
+	const inputs = yield* Ref.make([]);
+	const preparedFiles = yield* prepareFiles(captureFileInputs({
+		files,
+		sql,
+		used: inputs
+	}), sql);
+	const environment = {
+		files: engineFiles(preparedFiles),
+		id: Effect.tap(id, (value) => Ref.update(used, (context) => ({
+			...context,
+			ids: Array.append(context.ids, value)
+		}))),
+		key,
+		now: Effect.tap(now, (value) => Ref.update(used, (context) => ({
+			...context,
+			times: Array.append(context.times, value)
+		}))),
+		sql
+	};
+	const usedInputs = Effect.all({
+		files: Ref.get(inputs),
+		used: Ref.get(used)
+	});
+	const encoded = Effect.flatMap(usedInputs, (values) => Schema.encodeEffect(RecordedContext)({
+		...values.used,
+		files: values.files
+	}));
+	return {
+		environment,
+		recorded: Effect.orDie(encoded)
+	};
+});
+const replayedFrom = (recorded, fresh) => Effect.map(Ref.make(recorded), (left) => Effect.flatMap(Ref.modify(left, (values) => Array.matchLeft(values, {
+	onEmpty: () => [Option.none(), values],
+	onNonEmpty: (head, tail) => [Option.some(head), tail]
+})), Option.match({
+	onNone: () => fresh,
+	onSome: Effect.succeed
+})));
+const replaySources = (random, script) => Effect.gen(function* scriptedSources() {
+	const recorded = yield* Effect.orDie(Effect.flatMap(Ref.get(script), Schema.decodeEffect(RecordedContext)));
+	return {
+		files: (files, sql) => replayFileInputs({
+			files,
+			inputs: recorded.files,
+			sql
+		}),
+		id: yield* replayedFrom(recorded.ids, random.uuidV7()),
+		now: yield* replayedFrom(recorded.times, Clock.currentTimeMillis)
+	};
+});
+var CommandContext = class extends Context.Service()("@akterjs/effect/host/command/command-context.adapter/CommandContext", { make: Effect.map(SecureRandom.SecureRandom, (random) => ({ track: trackWith(Effect.succeed({
+	files: (files) => Effect.succeed(files),
+	id: random.uuidV7(),
+	now: Clock.currentTimeMillis
+})) })) }) {
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide(SecureRandom.layerWebCrypto));
+	/** Whether a failed statement's message reaches the caller or only the host's log. */
+	static statementDetail = StatementDetail;
+	static replaying(random, script) {
+		return { track: trackWith(replaySources(random, script)) };
+	}
+};
+export { CommandContext };

package/dist/host/command/command-id-age.pure.d.mts

@@ -0,0 +1,13 @@
+import { CommandIdExpiredError } from "../../contract/command/command-id-expired.errors.mjs";
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import { Effect, Option } from "effect";
+interface IdCheck {
+  readonly actor: string;
+  readonly commandId: string;
+  readonly keptSince: number;
+  readonly now: number;
+}
+declare const clockSkew: number;
+declare const mintedAtOf: (commandId: string) => Option.Option<number>;
+declare const checkCommandId: ({ actor, commandId, keptSince, now }: IdCheck) => Effect.Effect<void, CommandIdExpiredError | InvalidRequestError>;
+export { checkCommandId, clockSkew, mintedAtOf };

package/dist/host/command/command-id-age.pure.mjs

@@ -0,0 +1,31 @@
+import { CommandIdExpiredError } from "../../contract/command/command-id-expired.errors.mjs";
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import { mintedIdOf } from "../../contract/command/outbox-id.pure.mjs";
+import { Duration, Effect, Option } from "effect";
+// src/host/command/command-id-age.pure.ts
+const clockSkew = Duration.toMillis("5 minutes");
+const hexadecimal = 16;
+const uuidV7 = /^(?<high>[\da-f]{8})-(?<low>[\da-f]{4})-7[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu;
+const mintedAtOf = (commandId) => {
+	const minted = uuidV7.exec(mintedIdOf(commandId));
+	return Option.map(Option.fromNullishOr(minted?.groups), ({ high, low }) => Number.parseInt(`${high}${low}`, hexadecimal));
+};
+const checkCommandId = ({ actor, commandId, keptSince, now }) => {
+	const mintedAt = mintedAtOf(commandId);
+	if (Option.isNone(mintedAt)) return InvalidRequestError.make({
+		actor,
+		message: `command id ${commandId} is not a UUIDv7, so its age can't be checked against the history retention`
+	});
+	if (mintedAt.value < keptSince + clockSkew) return CommandIdExpiredError.make({
+		actor,
+		commandId,
+		keptSince,
+		mintedAt: mintedAt.value
+	});
+	if (mintedAt.value > now + clockSkew) return InvalidRequestError.make({
+		actor,
+		message: `command id ${commandId} was minted more than 5 minutes ahead`
+	});
+	return Effect.void;
+};
+export { checkCommandId, clockSkew, mintedAtOf };

package/dist/host/command/command-id-reuse.pure.d.mts

@@ -0,0 +1,28 @@
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import { Effect } from "effect";
+interface Reserving {
+  readonly actor: string;
+  readonly commandId: string;
+}
+interface Screening extends Reserving {
+  readonly principal: string;
+}
+interface Reuse extends Reserving {
+  readonly member: string;
+  readonly principal: string;
+  readonly recordedMember: string;
+  readonly recordedPrincipal: string;
+}
+declare const resultCommandId: (executionId: string) => string;
+declare const timerCommandId: (timer: string) => string;
+declare const resultMember: (job: string) => string;
+declare const isResultCommandId: (commandId: string) => boolean;
+declare const isTimerCommandId: (commandId: string) => boolean;
+declare const jobOfResult: (member: string) => string;
+/** The id of the job whose result `commandId` delivers, the inverse of `resultCommandId`. */
+declare const jobIdOfResult: (commandId: string) => string;
+declare const refuseReserved: ({ actor, commandId, principal }: Screening) => Effect.Effect<void, InvalidRequestError>;
+declare const sameCommand: ({ member, principal, recordedMember, recordedPrincipal }: Reuse) => boolean;
+declare const refuseReuse: ({ actor, commandId }: Reuse) => Effect.Effect<never, InvalidRequestError>;
+declare const reuseDefect: (reuse: Reuse) => Effect.Effect<never>;
+export { type Reuse, isResultCommandId, isTimerCommandId, jobIdOfResult, jobOfResult, refuseReserved, refuseReuse, resultCommandId, resultMember, reuseDefect, sameCommand, timerCommandId };

package/dist/host/command/command-id-reuse.pure.mjs

@@ -0,0 +1,38 @@
+import { Caller, actorKind } from "../../contract/caller/caller.schema.mjs";
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import { isOutboxCommandId } from "../../contract/command/outbox-id.pure.mjs";
+import { jsonCodec } from "../../contract/json-codec.pure.mjs";
+import { CommandIdReusedError } from "./command-id-reused.errors.mjs";
+import { Array, Effect, Option, Schema, String } from "effect";
+// src/host/command/command-id-reuse.pure.ts
+const resultPrefix = "result:";
+const resultMemberPrefix = "akter.result.";
+const timerPrefix = "timer:";
+const reservedPrefixes = [resultPrefix, timerPrefix];
+const resultCommandId = (executionId) => `${resultPrefix}${executionId}`;
+const timerCommandId = (timer) => `${timerPrefix}${timer}`;
+const resultMember = (job) => `${resultMemberPrefix}${job}`;
+const isResultCommandId = String.startsWith(resultPrefix);
+const isTimerCommandId = String.startsWith(timerPrefix);
+const jobOfResult = (member) => String.slice(13)(member);
+/** The id of the job whose result `commandId` delivers, the inverse of `resultCommandId`. */
+const jobIdOfResult = (commandId) => String.slice(7)(commandId);
+const fromActor = (principal) => Option.exists(Schema.decodeOption(jsonCodec(Caller))(principal), (caller) => caller.kind === actorKind);
+const refuseReserved = ({ actor, commandId, principal }) => {
+	if (isOutboxCommandId(commandId) && !fromActor(principal)) return InvalidRequestError.make({
+		actor,
+		message: `command id ${commandId} is reserved for messages actors send`
+	});
+	if (!Array.some(reservedPrefixes, (prefix) => String.startsWith(prefix)(commandId))) return Effect.void;
+	return InvalidRequestError.make({
+		actor,
+		message: `command id ${commandId} is reserved for the actor's own job results and timers`
+	});
+};
+const sameCommand = ({ member, principal, recordedMember, recordedPrincipal }) => member === recordedMember && principal === recordedPrincipal;
+const refuseReuse = ({ actor, commandId }) => Effect.fail(InvalidRequestError.make({
+	actor,
+	message: `command id ${commandId} was already used by another command`
+}));
+const reuseDefect = (reuse) => Effect.die(CommandIdReusedError.make(reuse));
+export { isResultCommandId, isTimerCommandId, jobIdOfResult, jobOfResult, refuseReserved, refuseReuse, resultCommandId, resultMember, reuseDefect, sameCommand, timerCommandId };

package/dist/host/command/command-id-reused.errors.d.mts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+declare const CommandIdReusedError_base: Schema.Class<CommandIdReusedError, Schema.TaggedStruct<"CommandIdReusedError", {
+  readonly actor: Schema.String;
+  readonly commandId: Schema.String;
+  readonly member: Schema.String;
+  readonly principal: Schema.String;
+  readonly recordedMember: Schema.String;
+  readonly recordedPrincipal: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class CommandIdReusedError extends CommandIdReusedError_base {}
+export {};

package/dist/host/command/command-id-reused.errors.mjs

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+// src/host/command/command-id-reused.errors.ts
+var CommandIdReusedError = class extends Schema.TaggedError()("CommandIdReusedError", {
+	actor: Schema.String,
+	commandId: Schema.String,
+	member: Schema.String,
+	principal: Schema.String,
+	recordedMember: Schema.String,
+	recordedPrincipal: Schema.String
+}) {};
+export { CommandIdReusedError };

package/dist/host/command/command-journal.sql.d.mts

@@ -0,0 +1,84 @@
+import { JournalEntry } from "../../contract/history/actor-journal.service.mjs";
+import { HostedOutcome } from "../../contract/hosted/hosted-outcome.contract.mjs";
+import "../../contract/actor/actor.contract.mjs";
+import { CommandRejectedError } from "./command-rejected.errors.mjs";
+import { CommandBatchJournal } from "./batch/command-batch.sql.mjs";
+import { FileDigest, fileDigests } from "../file/actor-files.sql.mjs";
+import { Effect, Option, Stream } from "effect";
+import { SqlClient, SqlError } from "effect/sql";
+interface JournalRow {
+  readonly at: number;
+  readonly command: string;
+  readonly commandId: string;
+  readonly exit: string;
+  readonly files: string;
+  readonly ids: string;
+  readonly payload: string;
+  readonly principal: string;
+  readonly times: string;
+}
+interface Lookup {
+  readonly commandId: string;
+  readonly sql: SqlClient.SqlClient;
+}
+interface Recording {
+  readonly row: JournalRow;
+  /** The seq to write the row at, inside an engine batch whose journal assigns it; otherwise SQLite picks it. */
+  readonly seq: Option.Option<number>;
+  readonly sql: SqlClient.SqlClient;
+}
+interface Settling {
+  readonly at: number;
+  readonly outcome: HostedOutcome;
+  readonly principal: string;
+  readonly sql: SqlClient.SqlClient;
+}
+interface Window {
+  readonly after: number;
+  readonly limit: number;
+  readonly since: number;
+  readonly sql: SqlClient.SqlClient;
+}
+interface Pruning {
+  readonly before: number;
+  readonly sql: SqlClient.SqlClient;
+}
+interface Paging {
+  readonly after: number;
+  readonly limit: number;
+  readonly sql: SqlClient.SqlClient;
+}
+interface ReplayRow extends JournalRow {
+  readonly seq: number;
+}
+interface WindowRow {
+  readonly commands: number;
+  readonly firstAt: number | null;
+  readonly firstSeq: number | null;
+  readonly lastAt: number | null;
+  readonly lastSeq: number | null;
+}
+type Read<Value> = Effect.Effect<Option.Option<Value>, SqlError.SqlError>;
+interface RecordedCommand {
+  readonly command: string;
+  readonly exit: string;
+  readonly principal: string;
+}
+type Write = Effect.Effect<void, SqlError.SqlError>;
+declare const recordedExit: ({ commandId, sql }: Lookup) => Read<string>;
+declare const recordedCommand: ({ commandId, sql }: Lookup) => Read<RecordedCommand>;
+declare const recordCommand: (recording: Recording) => Write;
+declare const currentState: (sql: SqlClient.SqlClient) => Read<string>;
+declare const settle: ({ at, outcome, principal, sql }: Settling) => Effect.Effect<string, CommandRejectedError | SqlError.SqlError>;
+declare const journalSince: ({ after, limit, since, sql }: Window) => Effect.Effect<readonly JournalEntry[], SqlError.SqlError>;
+declare const pruneJournal: ({ before, sql }: Pruning) => Write;
+declare const prunedBefore: (sql: SqlClient.SqlClient) => Read<number>;
+declare const journalWindow: (sql: SqlClient.SqlClient) => Effect.Effect<readonly WindowRow[], SqlError.SqlError>;
+declare const replayPage: ({ after, limit, sql }: Paging) => Effect.Effect<readonly ReplayRow[], SqlError.SqlError>;
+declare const replayRows: (sql: SqlClient.SqlClient) => Stream.Stream<ReplayRow, SqlError.SqlError>;
+/**
+ * Starts a copied database's history at the copy, such as a fork's: the commands before it belong to the actor it was
+ * copied from, and their file inputs name that actor's files, so the copy reads as pruned before its first command.
+ */
+declare const startJournalAtCopy: (sql: SqlClient.SqlClient) => Write;
+export { CommandBatchJournal, type FileDigest, type JournalRow, type RecordedCommand, type ReplayRow, type WindowRow, currentState, fileDigests, journalSince, journalWindow, pruneJournal, prunedBefore, recordCommand, recordedCommand, recordedExit, replayPage, replayRows, settle, startJournalAtCopy };

package/dist/host/command/command-journal.sql.mjs

@@ -0,0 +1,74 @@
+import { saveMessages } from "../outbox/actor-outbox.sql.mjs";
+import { saveTimers } from "../timer/actor-timers.sql.mjs";
+import { saveJobs, saveSignals } from "../job/job-journal.sql.mjs";
+import { CommandRejectedError } from "./command-rejected.errors.mjs";
+import { stalledCursor } from "./replay/replay-cursor.pure.mjs";
+import { retainFileInputs } from "./files/command-file-inputs.sql.mjs";
+import { CommandBatchJournal } from "./batch/command-batch.sql.mjs";
+import { fileDigests } from "../file/actor-files.sql.mjs";
+import { Array, Effect, Option, Stream } from "effect";
+// src/host/command/command-journal.sql.ts
+const recordedExit = ({ commandId, sql }) => Effect.map(sql`SELECT exit FROM akter_commands WHERE command_id = ${commandId}`, (rows) => Option.map(Array.head(rows), (row) => row.exit));
+const recordedCommand = ({ commandId, sql }) => Effect.map(sql`SELECT command, exit, principal FROM akter_commands WHERE command_id = ${commandId}`, Array.head);
+const insertCommand = ({ row, seq, sql }) => Option.match(seq, {
+	onNone: () => Effect.asVoid(sql`INSERT INTO akter_commands (command_id, command, payload, principal, exit, ids, times, files, at) VALUES (${row.commandId}, ${row.command}, ${row.payload}, ${row.principal}, ${row.exit}, ${row.ids}, ${row.times}, ${row.files}, ${row.at})`),
+	onSome: (at) => Effect.asVoid(sql`INSERT INTO akter_commands (seq, command_id, command, payload, principal, exit, ids, times, files, at) VALUES (${at}, ${row.commandId}, ${row.command}, ${row.payload}, ${row.principal}, ${row.exit}, ${row.ids}, ${row.times}, ${row.files}, ${row.at})`)
+});
+const recordCommand = (recording) => Effect.andThen(insertCommand(recording), retainFileInputs({
+	commandId: recording.row.commandId,
+	recorded: recording.row.files,
+	sql: recording.sql
+}));
+const currentState = (sql) => Effect.map(sql`SELECT value FROM akter_state WHERE id = 1`, (rows) => Option.map(Array.head(rows), (row) => row.value));
+const saveState = ({ sql, value }) => Effect.asVoid(sql`INSERT INTO akter_state (id, value) VALUES (1, ${value}) ON CONFLICT (id) DO UPDATE SET value = excluded.value`);
+const settle = ({ at, outcome, principal, sql }) => Option.match(outcome.state, {
+	onNone: () => Effect.fail(CommandRejectedError.make({ exit: outcome.exit })),
+	onSome: (value) => saveState({
+		sql,
+		value
+	}).pipe(Effect.andThen(saveTimers({
+		at,
+		principal,
+		sql,
+		timers: outcome.timers
+	})), Effect.andThen(saveMessages({
+		messages: outcome.messages,
+		sql
+	})), Effect.andThen(saveJobs({
+		jobs: outcome.jobs,
+		sql
+	})), Effect.andThen(saveSignals({
+		signals: outcome.signals,
+		sql
+	})), Effect.as(outcome.exit))
+});
+const journalSince = ({ after, limit, since, sql }) => sql`SELECT seq, command_id AS commandId, command, payload, principal, exit, at FROM akter_commands WHERE at >= ${since} AND seq > ${after} ORDER BY seq LIMIT ${limit}`;
+const pruneJournal = ({ before, sql }) => sql.withTransaction(Effect.gen(function* pruneHistory() {
+	yield* sql`INSERT INTO akter_meta (key, value) SELECT 'pruned_before', ${before} WHERE EXISTS (SELECT 1 FROM akter_commands WHERE at < ${before}) ON CONFLICT (key) DO UPDATE SET value = MAX(value, excluded.value)`;
+	yield* sql`INSERT INTO akter_blob_releases (claim, actor, blob) SELECT claim, actor, blob FROM akter_blob_history AS history WHERE command_id IN (SELECT command_id FROM akter_commands WHERE at < ${before}) AND NOT EXISTS (SELECT 1 FROM akter_blob_links WHERE claim = history.claim) AND NOT EXISTS (SELECT 1 FROM akter_blob_receipts WHERE claim = history.claim AND state IN ('uploading', 'prepared')) ON CONFLICT (claim) DO NOTHING`;
+	yield* sql`DELETE FROM akter_blob_history WHERE command_id IN (SELECT command_id FROM akter_commands WHERE at < ${before})`;
+	yield* sql`DELETE FROM akter_commands WHERE at < ${before}`;
+}));
+const prunedBefore = (sql) => Effect.map(sql`SELECT value FROM akter_meta WHERE key = 'pruned_before'`, (rows) => Option.map(Array.head(rows), (row) => row.value));
+const journalWindow = (sql) => sql`SELECT count(*) AS commands, min(seq) AS firstSeq, max(seq) AS lastSeq, (SELECT at FROM akter_commands ORDER BY seq LIMIT 1) AS firstAt, (SELECT at FROM akter_commands ORDER BY seq DESC LIMIT 1) AS lastAt FROM akter_commands`;
+const replayPage = ({ after, limit, sql }) => sql`SELECT seq, command_id AS commandId, command, payload, principal, exit, ids, times, files, at FROM akter_commands WHERE seq > ${after} ORDER BY seq LIMIT ${limit}`;
+const replayPageSize = 500;
+const beforeFirst = 0;
+const nextAfter = (rows) => Option.map(Option.filter(Array.last(rows), () => rows.length === replayPageSize), (row) => row.seq);
+const replayRows = (sql) => Stream.paginate(beforeFirst, (after) => Effect.flatMap(replayPage({
+	after,
+	limit: replayPageSize,
+	sql
+}), (rows) => Option.match(nextAfter(rows), {
+	onNone: () => Effect.succeed([rows, Option.none()]),
+	onSome: (cursor) => Option.match(stalledCursor(cursor, after), {
+		onNone: () => Effect.succeed([rows, Option.some(cursor)]),
+		onSome: Effect.die
+	})
+})));
+/**
+* Starts a copied database's history at the copy, such as a fork's: the commands before it belong to the actor it was
+* copied from, and their file inputs name that actor's files, so the copy reads as pruned before its first command.
+*/
+const startJournalAtCopy = (sql) => Effect.andThen(sql`INSERT INTO akter_meta (key, value) SELECT 'pruned_before', MAX(at) + 1 FROM akter_commands HAVING COUNT(*) > 0 ON CONFLICT (key) DO UPDATE SET value = MAX(value, excluded.value)`, sql`DELETE FROM akter_commands`);
+export { CommandBatchJournal, currentState, fileDigests, journalSince, journalWindow, pruneJournal, prunedBefore, recordCommand, recordedCommand, recordedExit, replayPage, replayRows, settle, startJournalAtCopy };

package/dist/host/command/command-rejected.errors.d.mts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+declare const CommandRejectedError_base: Schema.Class<CommandRejectedError, Schema.TaggedStruct<"CommandRejectedError", {
+  readonly exit: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class CommandRejectedError extends CommandRejectedError_base {}
+export {};

package/dist/host/command/command-rejected.errors.mjs

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+// src/host/command/command-rejected.errors.ts
+var CommandRejectedError = class extends Schema.TaggedError()("CommandRejectedError", { exit: Schema.String }) {};
+export { CommandRejectedError };

package/dist/host/command/command-replay.service.d.mts

@@ -0,0 +1,62 @@
+import { ActorUnavailableError } from "../../contract/client/actor-unavailable.errors.mjs";
+import { HostedError } from "../../contract/hosted/hosted-error.contract.mjs";
+import { HostedActor } from "../../contract/actor/actor.contract.mjs";
+import { HistoryPrunedError } from "./history-pruned.errors.mjs";
+import { ActorDatabase } from "../actor/actor-database.service.mjs";
+import { FileDigest } from "../file/actor-files.sql.mjs";
+import "./command-journal.sql.mjs";
+import { SqliteDriver } from "../sqlite/sqlite-driver.service.mjs";
+import { Context, Effect, FileSystem, Layer, Option } from "effect";
+import { SecureRandom } from "effect/crypto";
+interface Replaying {
+  readonly actor: HostedActor;
+  readonly database: string;
+  readonly key: string;
+}
+interface JournalPoint {
+  readonly at: number;
+  readonly seq: number;
+}
+interface ReplayWindow {
+  readonly commands: number;
+  readonly first: Option.Option<JournalPoint>;
+  readonly last: Option.Option<JournalPoint>;
+}
+type ReplayedOutcome = {
+  readonly exit: string;
+  readonly kind: "journaled";
+} | {
+  readonly error: HostedError;
+  readonly kind: "refused";
+};
+interface ReplayDifference {
+  readonly actual: ReplayedOutcome;
+  readonly at: number;
+  readonly command: string;
+  readonly commandId: string;
+  readonly expected: string;
+  readonly seq: number;
+}
+interface FilesDifference {
+  readonly actual: readonly FileDigest[];
+  readonly expected: readonly FileDigest[];
+}
+interface ReplayReport {
+  readonly actor: string;
+  readonly difference: Option.Option<ReplayDifference>;
+  readonly files: Option.Option<FilesDifference>;
+  readonly key: string;
+  readonly window: ReplayWindow;
+}
+type ReplayFailure = ActorUnavailableError | HistoryPrunedError;
+declare const CommandReplay_base: Context.ServiceClass<CommandReplay, "@akterjs/effect/host/command/command-replay.service/CommandReplay", {
+  readonly replay: (replaying: Replaying) => Effect.Effect<ReplayReport, ReplayFailure>;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly replay: (replaying: Replaying) => Effect.Effect<ReplayReport, ReplayFailure>;
+  }, never, ActorDatabase | FileSystem.FileSystem | SecureRandom.SecureRandom | SqliteDriver>;
+};
+export declare class CommandReplay extends CommandReplay_base {
+  static readonly layer: Layer.Layer<CommandReplay, never, FileSystem.FileSystem | SqliteDriver>;
+}
+export type { FilesDifference, JournalPoint, ReplayDifference, ReplayFailure, ReplayReport, ReplayWindow, ReplayedOutcome, Replaying };

package/dist/host/command/command-replay.service.mjs

@@ -0,0 +1,140 @@
+import { ActorUnavailableError } from "../../contract/client/actor-unavailable.errors.mjs";
+import { HistoryPrunedError } from "./history-pruned.errors.mjs";
+import { ActorDatabase } from "../actor/actor-database.service.mjs";
+import { CommandContext } from "./command-context.adapter.mjs";
+import { fileDigests } from "../file/actor-files.sql.mjs";
+import { journalWindow, prunedBefore, recordedExit, replayRows } from "./command-journal.sql.mjs";
+import { CommandRunner } from "./command-runner.service.mjs";
+import { SqliteDriver } from "../sqlite/sqlite-driver.service.mjs";
+import { Array, Context, Effect, FileSystem, Layer, Option, Ref, Stream } from "effect";
+import { SecureRandom } from "effect/crypto";
+// src/host/command/command-replay.service.ts
+const noneRecorded = {
+	files: "[]",
+	ids: "[]",
+	times: "[]"
+};
+const emptyWindow = {
+	commands: 0,
+	first: Option.none(),
+	last: Option.none()
+};
+const pointOf = (seq, at) => Option.all({
+	at: Option.fromNullishOr(at),
+	seq: Option.fromNullishOr(seq)
+});
+const windowOf = (rows) => Option.match(Array.head(rows), {
+	onNone: () => emptyWindow,
+	onSome: (row) => ({
+		commands: row.commands,
+		first: pointOf(row.firstSeq, row.firstAt),
+		last: pointOf(row.lastSeq, row.lastAt)
+	})
+});
+const journaled = (exit) => ({
+	exit,
+	kind: "journaled"
+});
+const refused = (error) => ({
+	error,
+	kind: "refused"
+});
+const runRow = ({ key, opened, runner }, row) => runner.replay({
+	opened,
+	request: {
+		commandId: row.commandId,
+		key,
+		member: row.command,
+		payload: row.payload,
+		principal: row.principal
+	}
+});
+const replayRow = (replayer) => Effect.fnUntraced(function* replayOne(row) {
+	yield* Ref.set(replayer.script, {
+		files: row.files,
+		ids: row.ids,
+		times: row.times
+	});
+	const actual = yield* runRow(replayer, row).pipe(Effect.map(journaled), Effect.catchTag("SqlError", Effect.fail, (error) => Effect.map(recordedExit({
+		commandId: row.commandId,
+		sql: replayer.opened.sql
+	}), Option.match({
+		onNone: () => refused(error),
+		onSome: journaled
+	}))));
+	if (actual.kind === "journaled" && actual.exit === row.exit) return Option.none();
+	return Option.some({
+		actual,
+		at: row.at,
+		command: row.command,
+		commandId: row.commandId,
+		expected: row.exit,
+		seq: row.seq
+	});
+});
+const sameDigest = (left, right) => left.path === right.path && left.sha256 === right.sha256 && left.bytes === right.bytes;
+const sameDigests = Array.makeEquivalence(sameDigest);
+const filesDifference = (source, replayed) => Effect.map(Effect.all({
+	actual: fileDigests(replayed),
+	expected: fileDigests(source)
+}), (digests) => Option.liftPredicate(digests, ({ actual, expected }) => !sameDigests(actual, expected)));
+const unpruned = (actor, key, source) => Effect.flatMap(prunedBefore(source), Option.match({
+	onNone: () => Effect.void,
+	onSome: (coveredSince) => Effect.fail(HistoryPrunedError.make({
+		actor: actor.name,
+		coveredSince,
+		key
+	}))
+}));
+const firstDifference = (replayer, source) => replayRows(source).pipe(Stream.mapEffect(replayRow(replayer)), Stream.filter(Option.isSome), Stream.runHead, Effect.map(Option.flatten));
+var CommandReplay = class extends Context.Service()("@akterjs/effect/host/command/command-replay.service/CommandReplay", { make: Effect.gen(function* makeCommandReplay() {
+	const driver = yield* SqliteDriver;
+	const database = yield* ActorDatabase;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const random = yield* SecureRandom.SecureRandom;
+	const replayFrom = Effect.fnUntraced(function* replayFrom({ actor, key }, source) {
+		yield* unpruned(actor, key, source);
+		const window = yield* journalWindow(source);
+		const script = yield* Ref.make(noneRecorded);
+		const context = CommandContext.replaying(random, script);
+		const runner = yield* Effect.provideService(CommandRunner.make, CommandContext, context);
+		const opened = yield* database.replay({
+			actor,
+			source
+		});
+		const difference = yield* firstDifference({
+			key,
+			opened,
+			runner,
+			script
+		}, source);
+		const files = yield* filesDifference(source, opened.sql);
+		return {
+			actor: actor.name,
+			difference,
+			files,
+			key,
+			window: windowOf(window)
+		};
+	});
+	const replayStored = Effect.fnUntraced(function* replayStored(replaying) {
+		if (!(yield* fileSystem.exists(replaying.database))) return {
+			actor: replaying.actor.name,
+			difference: Option.none(),
+			files: Option.none(),
+			key: replaying.key,
+			window: emptyWindow
+		};
+		const source = yield* driver.openQueryOnly(replaying.database);
+		return yield* source.withTransaction(replayFrom(replaying, source));
+	}, Effect.scoped);
+	return { replay: Effect.fn("CommandReplay.replay")(function* replay(replaying) {
+		return yield* replayStored(replaying).pipe(Effect.catchTag("HistoryPrunedError", Effect.fail, (failure) => Effect.fail(ActorUnavailableError.make({
+			actor: replaying.actor.name,
+			message: failure.message
+		}))));
+	}) };
+}) }) {
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide([ActorDatabase.layer, SecureRandom.layerWebCrypto]));
+};
+export { CommandReplay };

package/dist/host/command/command-reply.pure.d.mts

@@ -0,0 +1,8 @@
+import { ActorAlreadyExistsError } from "../../contract/actor/actor-already-exists.errors.mjs";
+import { HandlerFailedError } from "../../contract/hosted/handler-failed.errors.mjs";
+import { Effect, Schema } from "effect";
+declare const JournaledFailure: Schema.Union<readonly [typeof ActorAlreadyExistsError, typeof HandlerFailedError]>;
+type JournaledFailure = typeof JournaledFailure.Type;
+declare const journalFailure: (failed: JournaledFailure) => Effect.Effect<string>;
+declare const replyOf: (journaled: string) => Effect.Effect<string, JournaledFailure>;
+export { journalFailure, replyOf };

package/dist/host/command/command-reply.pure.mjs

@@ -0,0 +1,12 @@
+import { ActorAlreadyExistsError } from "../../contract/actor/actor-already-exists.errors.mjs";
+import { HandlerFailedError } from "../../contract/hosted/handler-failed.errors.mjs";
+import { Effect, Option, Schema } from "effect";
+// src/host/command/command-reply.pure.ts
+const JournaledFailure = Schema.Union([ActorAlreadyExistsError, HandlerFailedError]);
+const JournaledFailureJson = Schema.fromJsonString(JournaledFailure);
+const journalFailure = (failed) => Effect.orDie(Schema.encodeEffect(JournaledFailureJson)(failed));
+const replyOf = (journaled) => Option.match(Schema.decodeOption(JournaledFailureJson)(journaled), {
+	onNone: () => Effect.succeed(journaled),
+	onSome: (failed) => Effect.fail(failed)
+});
+export { journalFailure, replyOf };