@akterjs/effect 0.0.0-stage → 0.1.0

package/dist/host/file/local-blob-owner.sql.d.mts

@@ -0,0 +1,30 @@
+import { BlobOwner, TransferEffect } from "../blob/reference/blob-transfer.pure.mjs";
+import { LocalBlobHome } from "./blob-home.sql.mjs";
+import { LocalBlobHomes } from "./local-blob-home.service.mjs";
+import { Effect, Option, Scope } from "effect";
+import { SqlClient } from "effect/sql";
+interface LocalOwner {
+  readonly actor: string;
+  readonly sql: SqlClient.SqlClient;
+}
+interface LocalActorFiles {
+  readonly home: LocalBlobHome;
+  readonly kick: Effect.Effect<void>;
+  readonly owner: BlobOwner;
+  readonly sql: SqlClient.SqlClient;
+}
+interface OwnerOpening extends LocalOwner {
+  readonly exclusive: BlobOwner["exclusive"];
+  readonly snapshot: BlobOwner["snapshot"];
+}
+/**
+ * The blob owner of one actor whose writes go through `exclusive`, the actor's own serializer, so a file write never
+ * interleaves with a command's transaction on the same connection.
+ */
+declare const blobOwnerOn: ({ actor, exclusive, snapshot, sql }: OwnerOpening) => TransferEffect<BlobOwner>;
+declare const localBlobOwner: ({ actor, sql }: LocalOwner) => TransferEffect<BlobOwner, Scope.Scope>;
+/** Recovers and settles an owner's transfers on its home, then keeps its references settled until the scope closes. */
+declare const actorFilesOn: ({ home, owner, sql }: Omit<LocalActorFiles, "kick">) => TransferEffect<LocalActorFiles, Scope.Scope>;
+type LocalActorFileOpener = (opening: LocalOwner) => TransferEffect<Option.Option<LocalActorFiles>, Scope.Scope>;
+declare const localActorFiles: (homes: Option.Option<LocalBlobHomes["Service"]>) => LocalActorFileOpener;
+export { type LocalActorFileOpener, type LocalActorFiles, type LocalOwner, actorFilesOn, blobOwnerOn, localActorFiles, localBlobOwner };

package/dist/host/file/local-blob-owner.sql.mjs

@@ -0,0 +1,68 @@
+import { actorExclusive } from "../actor/actor-exclusive.pure.mjs";
+import { blobForks } from "../blob/reference/blob-forks.sql.mjs";
+import { blobReceipts, prepareReceipts } from "../blob/reference/blob-receipts.sql.mjs";
+import { localFileUpkeep } from "./local-file-upkeep.pure.mjs";
+import { Effect, Option } from "effect";
+// src/host/file/local-blob-owner.sql.ts
+/**
+* The blob owner of one actor whose writes go through `exclusive`, the actor's own serializer, so a file write never
+* interleaves with a command's transaction on the same connection.
+*/
+const blobOwnerOn = ({ actor, exclusive, snapshot, sql }) => Effect.gen(function* openBlobOwner() {
+	const receipts = blobReceipts({
+		actor,
+		sql
+	});
+	yield* exclusive(Effect.andThen(prepareReceipts(sql), receipts.resume));
+	return {
+		actor,
+		exclusive,
+		forks: blobForks({
+			actor,
+			sql
+		}),
+		receipts,
+		snapshot,
+		transaction: sql.withTransaction
+	};
+});
+const localBlobOwner = ({ actor, sql }) => Effect.gen(function* openLocalBlobOwner() {
+	const exclusive = yield* actorExclusive;
+	const snapshot = yield* actorExclusive;
+	yield* Effect.addFinalizer(() => Effect.andThen(snapshot.close, exclusive.close));
+	return yield* blobOwnerOn({
+		actor,
+		exclusive: exclusive.run,
+		snapshot: snapshot.run,
+		sql
+	});
+});
+/** Recovers and settles an owner's transfers on its home, then keeps its references settled until the scope closes. */
+const actorFilesOn = ({ home, owner, sql }) => Effect.gen(function* openActorFiles() {
+	yield* home.transfers.recover(owner);
+	yield* home.transfers.settle(owner);
+	const { kick } = yield* localFileUpkeep({
+		home,
+		owner
+	});
+	return {
+		home,
+		kick,
+		owner,
+		sql
+	};
+});
+const openLocalActorFiles = (homes, opening) => Effect.gen(function* openActorFiles() {
+	const home = yield* homes.get;
+	const owner = yield* localBlobOwner(opening);
+	return yield* actorFilesOn({
+		home,
+		owner,
+		sql: opening.sql
+	});
+});
+const localActorFiles = (homes) => (opening) => Option.match(homes, {
+	onNone: () => Effect.succeedNone,
+	onSome: (available) => Effect.asSome(openLocalActorFiles(available, opening))
+});
+export { actorFilesOn, blobOwnerOn, localActorFiles, localBlobOwner };

package/dist/host/file/local-file-upkeep.pure.d.mts

@@ -0,0 +1,12 @@
+import { BlobOwner } from "../blob/reference/blob-transfer.pure.mjs";
+import { LocalBlobHome } from "./blob-home.sql.mjs";
+import "./local-blob-home.service.mjs";
+import { Effect, Scope } from "effect";
+interface FileUpkeep {
+  readonly home: LocalBlobHome;
+  readonly owner: BlobOwner;
+}
+declare const localFileUpkeep: ({ home, owner }: FileUpkeep) => Effect.Effect<{
+  readonly kick: Effect.Effect<void>;
+}, never, Scope.Scope>;
+export { localFileUpkeep };

package/dist/host/file/local-file-upkeep.pure.mjs

@@ -0,0 +1,41 @@
+import { Array, Clock, Effect, Queue } from "effect";
+// src/host/file/local-file-upkeep.pure.ts
+const oneNotification = 1;
+const retryEvery = "1 minute";
+/** Whether the owner is erased, and which of its releases are ready at `now` (a hold keeps some waiting). */
+const pendingAt = (owner, now) => {
+	const read = Effect.all({
+		erased: owner.receipts.erased,
+		releases: owner.receipts.releases(now)
+	});
+	return owner.exclusive(owner.transaction(read));
+};
+const localFileUpkeep = ({ home, owner }) => Effect.gen(function* keepLocalFiles() {
+	const events = yield* Queue.sliding(oneNotification);
+	const kick = Effect.asVoid(Queue.offer(events, true));
+	const collect = Effect.gen(function* collectPages() {
+		for (;;) {
+			const removed = yield* home.transfers.collect;
+			if (!Array.isReadonlyArrayNonEmpty(removed)) return;
+			yield* Effect.yieldNow;
+		}
+	});
+	const pass = Effect.gen(function* settleFileReferences() {
+		yield* home.transfers.settle(owner);
+		yield* collect;
+		const now = yield* Clock.currentTimeMillis;
+		const pending = yield* pendingAt(owner, now);
+		if (!pending.erased && Array.isReadonlyArrayNonEmpty(pending.releases)) yield* kick;
+	}).pipe(Effect.catchTags({
+		BlobTransferError: () => Effect.logWarning("local file cleanup will retry"),
+		SqlError: () => Effect.logWarning("local file cleanup will retry")
+	}));
+	const waiting = Effect.timeoutOrElse(Queue.take(events), {
+		duration: retryEvery,
+		orElse: () => Effect.succeed(false)
+	});
+	const work = Effect.forever(Effect.andThen(waiting, pass));
+	yield* Effect.forkScoped(work);
+	return { kick };
+});
+export { localFileUpkeep };

package/dist/host/file/replay-file-storage.sql.d.mts

@@ -0,0 +1,7 @@
+import { OpenedActor } from "../actor/actor-database.service.mjs";
+import { LocalBlobHomes } from "./local-blob-home.service.mjs";
+import { Effect, Option } from "effect";
+import { SqlClient, SqlError } from "effect/sql";
+type ReplayFileRestorer = (source: SqlClient.SqlClient, blank: OpenedActor) => Effect.Effect<OpenedActor, SqlError.SqlError>;
+declare const replayFileStorage: (homes: Option.Option<LocalBlobHomes["Service"]>) => ReplayFileRestorer;
+export { replayFileStorage };

package/dist/host/file/replay-file-storage.sql.mjs

@@ -0,0 +1,26 @@
+import { FilesUnavailableError } from "../../contract/file/files-unavailable.errors.mjs";
+import { actorFileStorage } from "./actor-file-storage.sql.mjs";
+import { Array, Effect, Option, Stream } from "effect";
+// src/host/file/replay-file-storage.sql.ts
+const replayFileStorage = (homes) => {
+	const open = Option.match(homes, {
+		onNone: () => () => Stream.fail(FilesUnavailableError.make({ message: "files aren't available on this host" })),
+		onSome: (available) => (opening) => Stream.unwrap(Effect.map(available.get, (home) => home.transfers.open(opening)))
+	});
+	return (source, blank) => Effect.gen(function* replayFiles() {
+		const owners = yield* source`SELECT actor, state FROM akter_blob_owners WHERE id = 1`;
+		const owner = Array.head(owners);
+		if (Option.isNone(owner)) return blank;
+		const stored = owner.value;
+		yield* blank.sql`INSERT INTO akter_blob_owners (id, actor, state) VALUES (1, ${stored.actor}, ${stored.state})`;
+		return {
+			...blank,
+			files: (sql) => actorFileStorage({
+				actor: stored.actor,
+				open,
+				sql
+			})
+		};
+	});
+};
+export { replayFileStorage };

package/dist/host/fork/actor-fork.sql.d.mts

@@ -0,0 +1,52 @@
+import { Effect, Option } from "effect";
+import { SqlClient, SqlError } from "effect/sql";
+type Sql<Value> = Effect.Effect<Value, SqlError.SqlError>;
+/** A fork the parent recorded: `intent` until its child is published, then `published`. */
+interface ForkRecord {
+  readonly child: string;
+  readonly state: "intent" | "published";
+  readonly version: number;
+}
+interface ForkIntent {
+  readonly into: string;
+  readonly version: number;
+}
+/** Where a forked actor came from, kept in its `akter_meta` and exported as its lineage (ADR 0019). */
+interface Lineage {
+  readonly forkId: string;
+  /** The parent as `<Actor>/<key segment>`, the form both engines write. */
+  readonly origin: string;
+  readonly version: number;
+}
+declare const prepareForks: (sql: SqlClient.SqlClient) => Sql<void>;
+interface Named {
+  readonly commandId: string;
+  readonly sql: SqlClient.SqlClient;
+}
+declare const recordedFork: ({ commandId, sql }: Named) => Sql<Option.Option<ForkRecord>>;
+declare const recordIntent: ({ commandId, into, sql, version }: ForkIntent & Named) => Sql<void>;
+declare const markPublished: ({ commandId, sql }: Named) => Sql<void>;
+/**
+ * Makes a copy of an actor's database into a quiet fork (ADR 0017): its timers, undelivered messages and open jobs
+ * are dropped or cancelled, its history starts at the copy, its file rows are cleared for the fork to inherit the
+ * files under its own claims, its `akter_meta` keeps only `copiedMeta`, and its lineage is recorded. Runs on the copy
+ * before anything opens it as an actor.
+ */
+declare const quietCopy: ({ forkId, origin, sql, version }: Lineage & {
+  readonly sql: SqlClient.SqlClient;
+}) => Sql<void>;
+/** The file fork a staged copy began: the child's file identity, and the parent's it forks from. */
+interface ForkedFiles {
+  readonly actor: string;
+  readonly origin: string;
+}
+/**
+ * The file fork recorded in a quieted copy, or none before its files were forked. Read it only from a copy whose
+ * `fork.id` is this fork's: before quietCopy commits, a copy holds its parent's own file rows.
+ */
+declare const forkedFiles: (sql: SqlClient.SqlClient) => Sql<Option.Option<ForkedFiles>>;
+/** The fork id a published child carries, or none for an actor that was not forked. */
+declare const forkIdOf: (sql: SqlClient.SqlClient) => Sql<Option.Option<string>>;
+/** The lineage a forked actor's `akter_meta` records, or none for an actor that was not forked. */
+declare const lineageOf: (sql: SqlClient.SqlClient) => Sql<Option.Option<Lineage>>;
+export { type ForkRecord, type ForkedFiles, type Lineage, forkIdOf, forkedFiles, lineageOf, markPublished, prepareForks, quietCopy, recordIntent, recordedFork };

package/dist/host/fork/actor-fork.sql.mjs

@@ -0,0 +1,42 @@
+import { clearCopiedFiles } from "../blob/reference/blob-receipts.sql.mjs";
+import { startJournalAtCopy } from "../command/command-journal.sql.mjs";
+import { cancelOpenJobs } from "../job/job-journal.sql.mjs";
+import { Array, Effect, Option } from "effect";
+// src/host/fork/actor-fork.sql.ts
+/**
+* The `akter_meta` keys a fork's copy keeps: its layout version, and where its history was last pruned. Every other
+* key belongs to the parent alone, such as the key of the parent's last export (`export_record`) or the parent's own
+* lineage, so a copy drops it. A key added to `akter_meta` stays with the parent until it is listed here.
+*/
+const copiedMeta = ["layout", "pruned_before"];
+const prepareForks = (sql) => Effect.asVoid(sql`CREATE TABLE IF NOT EXISTS akter_forks (command_id TEXT PRIMARY KEY, child TEXT NOT NULL, state TEXT NOT NULL CHECK (state IN ('intent', 'published')), version INTEGER NOT NULL) STRICT`);
+const recordedFork = ({ commandId, sql }) => Effect.map(sql`SELECT child, state, version FROM akter_forks WHERE command_id = ${commandId}`, Array.head);
+const recordIntent = ({ commandId, into, sql, version }) => Effect.asVoid(sql`INSERT INTO akter_forks (command_id, child, state, version) VALUES (${commandId}, ${into}, 'intent', ${version}) ON CONFLICT (command_id) DO UPDATE SET version = excluded.version`);
+const markPublished = ({ commandId, sql }) => Effect.asVoid(sql`UPDATE akter_forks SET state = 'published' WHERE command_id = ${commandId}`);
+/**
+* Makes a copy of an actor's database into a quiet fork (ADR 0017): its timers, undelivered messages and open jobs
+* are dropped or cancelled, its history starts at the copy, its file rows are cleared for the fork to inherit the
+* files under its own claims, its `akter_meta` keeps only `copiedMeta`, and its lineage is recorded. Runs on the copy
+* before anything opens it as an actor.
+*/
+const quietCopy = ({ forkId, origin, sql, version }) => sql.withTransaction(Effect.gen(function* quietFork() {
+	yield* prepareForks(sql);
+	yield* sql`DELETE FROM akter_forks`;
+	yield* sql`DELETE FROM akter_timers`;
+	yield* sql`DELETE FROM akter_outbox`;
+	yield* cancelOpenJobs(sql);
+	yield* startJournalAtCopy(sql);
+	yield* clearCopiedFiles(sql);
+	yield* sql`DELETE FROM akter_meta WHERE key NOT IN ${sql.in(copiedMeta)}`;
+	yield* sql`INSERT INTO akter_meta (key, value) VALUES ('fork.origin', ${origin}), ('fork.id', ${forkId}), ('fork.version', ${version})`;
+}));
+/**
+* The file fork recorded in a quieted copy, or none before its files were forked. Read it only from a copy whose
+* `fork.id` is this fork's: before quietCopy commits, a copy holds its parent's own file rows.
+*/
+const forkedFiles = (sql) => Effect.map(sql`SELECT owner.actor AS actor, fork.origin AS origin FROM akter_blob_owners AS owner, akter_blob_fork AS fork`, Array.head);
+/** The fork id a published child carries, or none for an actor that was not forked. */
+const forkIdOf = (sql) => Effect.map(sql`SELECT value FROM akter_meta WHERE key = 'fork.id'`, (rows) => Option.map(Array.head(rows), (row) => row.value));
+/** The lineage a forked actor's `akter_meta` records, or none for an actor that was not forked. */
+const lineageOf = (sql) => Effect.map(sql`SELECT origin.value AS origin, id.value AS forkId, version.value AS version FROM akter_meta AS origin JOIN akter_meta AS id ON id.key = 'fork.id' JOIN akter_meta AS version ON version.key = 'fork.version' WHERE origin.key = 'fork.origin'`, Array.head);
+export { forkIdOf, forkedFiles, lineageOf, markPublished, prepareForks, quietCopy, recordIntent, recordedFork };

package/dist/host/fork/fork-computers.adapter.d.mts

@@ -0,0 +1,43 @@
+import { ActorUnavailableError } from "../../contract/client/actor-unavailable.errors.mjs";
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import { ComputerAddress } from "../../contract/computer/computer-client.contract.mjs";
+import { Context, Effect, FileSystem, Layer, Option, Path } from "effect";
+/** One actor fork's computers: the parent's, copied into the child, under the store's computers directory. */
+interface ComputersFork {
+  readonly child: ComputerAddress;
+  /** The fork's id: the hold it keeps on the parent's computers, and the name of the mark on the child's. */
+  readonly fork: string;
+  readonly parent: ComputerAddress;
+  readonly root: string;
+}
+/** One of the parent's computers the fork copies. */
+interface Held {
+  readonly name: string;
+}
+type ForkFailure = ActorUnavailableError | InvalidRequestError;
+type Needs = FileSystem.FileSystem | Path.Path;
+type Releasing = ComputersFork & {
+  readonly held: Option.Option<readonly Held[]>;
+};
+type Swept = Effect.Error<ReturnType<FileSystem.FileSystem["remove"]>>;
+/** What `ForkComputers` offers, with the file system it runs on provided when its layer is built. */
+interface ForkComputersOperations {
+  readonly copy: (forking: ComputersFork & {
+    readonly held: readonly Held[];
+  }) => Effect.Effect<void, ForkFailure>;
+  readonly discard: (forking: ComputersFork) => Effect.Effect<void, ForkFailure>;
+  readonly hold: (forking: ComputersFork) => Effect.Effect<readonly Held[], ForkFailure>;
+  readonly release: (forking: Releasing) => Effect.Effect<void, ForkFailure>;
+  readonly settle: (forking: Releasing) => Effect.Effect<void, ForkFailure>;
+  readonly sweep: <Unreadable>(root: string, storedActors: Effect.Effect<ReadonlySet<string>, Unreadable>) => Effect.Effect<void, Unreadable | Swept>;
+}
+declare const ForkComputers_base: Context.ServiceClass<ForkComputers, "@akterjs/effect/host/fork/fork-computers.adapter/ForkComputers", ForkComputersOperations>;
+/**
+ * The computers of an actor fork on the local engine: `hold` the parent's before the cut, `copy` them into the child
+ * before it is published, stopped, then `settle` once it is, or `release` after a failure, so `discard` finds the
+ * copies to remove. `sweep` settles what crashed forks left when a host starts.
+ */
+export declare class ForkComputers extends ForkComputers_base {
+  static readonly layer: Layer.Layer<ForkComputers, never, Needs>;
+}
+export type { ComputersFork, Held };

package/dist/host/fork/fork-computers.adapter.mjs

@@ -0,0 +1,193 @@
+import { ActorUnavailableError } from "../../contract/client/actor-unavailable.errors.mjs";
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import { ActorComputerClients } from "../../contract/computer/computer-client.adapter.mjs";
+import { localLog } from "../computer/local-computer-log.layer.mjs";
+import { admitted, findRecord, listed, placeOf, saveRecord } from "../computer/local-computer-records.layer.mjs";
+import { Array, Clock, Context, Effect, FileSystem, Layer, Match, Option, Path, Semaphore, String as String$1 } from "effect";
+// src/host/fork/fork-computers.adapter.ts
+const markPrefix = "@fork-";
+const oneAtATime = 1;
+const markOf = (fork) => `${markPrefix}${encodeURIComponent(fork)}`;
+const storeOf = Effect.fnUntraced(function* storeOf(root) {
+	const path = yield* Path.Path;
+	return {
+		admission: yield* Semaphore.make(oneAtATime),
+		path,
+		root
+	};
+});
+const failedWith = (actor) => (failure) => Match.value(failure).pipe(Match.tags({
+	ActorUnavailableError: (unavailable) => unavailable,
+	ComputerHeldError: ({ computer, hold }) => ActorUnavailableError.make({
+		actor,
+		message: `${actor} can't fork while its computer ${computer} is held by ${hold}, a fork that didn't finish. Retry that fork, or resume the computer with the hold ${hold}, to release it.`
+	}),
+	ComputerLimitError: ({ maximum }) => InvalidRequestError.make({
+		actor,
+		message: `${actor} can't fork: copying its computers would pass the store's limit of ${String(maximum)} computers. Remove a computer, then fork again.`
+	}),
+	InvalidRequestError: (invalid) => invalid
+}), Match.orElse(() => ActorUnavailableError.make({
+	actor,
+	message: "the fork didn't copy its computers. Retry it with the same id."
+})));
+const answered = (actor) => (effect) => Effect.mapError(effect, failedWith(actor));
+const foundIn = (place) => Effect.map(findRecord(place), Option.map(() => ({ place })));
+/** The parent's computers as their directories record them, by name. */
+const parentComputers = Effect.fnUntraced(function* parentComputers(store, parent) {
+	const names = yield* listed(placeOf(store)(parent, "").actor);
+	const places = Array.map(Array.sort(names, String$1.Order), (name) => placeOf(store)(parent, name));
+	const found = yield* Effect.forEach(places, foundIn);
+	return Array.getSomes(found);
+});
+/** The parent's computer client when the engine runs computers; none when nothing can change them meanwhile. */
+const clientOf = (parent) => Effect.map(Effect.serviceOption(ActorComputerClients), Option.map((clients) => clients.connect(parent)));
+/** A computer that is gone, or that no engine runs, needs no hold: nothing can change it while the fork copies it. */
+const unheld = (effect) => Effect.asVoid(effect).pipe(Effect.catchTags({
+	ComputerLostError: () => Effect.void,
+	ComputerNotFoundError: () => Effect.void,
+	ComputersUnavailableError: () => Effect.void
+}));
+const heldOf = ({ place }) => ({ name: place.name });
+/**
+* Holds each of the parent's computers paused under the fork's id, so no step or ensure changes one until the fork
+* lets it go, and answers which the fork copies. A hold survives a restart, and the same hold taken again is a resend.
+*/
+const holdParent = ({ fork, parent, root }) => answered(parent.actor)(Effect.gen(function* holdComputers() {
+	const store = yield* storeOf(root);
+	const computers = yield* parentComputers(store, parent);
+	const client = yield* clientOf(parent);
+	if (Option.isSome(client)) {
+		const hold = ({ place }) => unheld(client.value.pause(place.name, { hold: fork }));
+		yield* Effect.forEach(computers, hold, { discard: true });
+	}
+	return Array.map(computers, heldOf);
+}));
+/** Copies one computer's disk and spec into the child, stopped: a fork copies its files and none of its processes. */
+const copyOne = Effect.fnUntraced(function* copyOne(source, target) {
+	const fs = yield* FileSystem.FileSystem;
+	const record = yield* findRecord(source);
+	if (Option.isNone(record)) return;
+	yield* fs.makeDirectory(target.directory, { recursive: true });
+	if (yield* fs.exists(source.disk)) yield* fs.copy(source.disk, target.disk);
+	const createdAt = yield* Clock.currentTimeMillis;
+	yield* saveRecord(target, {
+		createdAt,
+		spec: record.value.spec,
+		state: "stopped"
+	});
+});
+const copied = (store, { child, fork, parent }) => ({ name }) => {
+	const source = placeOf(store)(parent, name);
+	const target = placeOf(store)(child, name);
+	const note = `copied from ${parent.actor}/${parent.key} by the fork ${fork}, stopped`;
+	return Effect.andThen(admitted({
+		computer: name,
+		store
+	})(copyOne(source, target)), localLog(store.path).note(target, "info", note));
+};
+const alreadyKept = ({ child, parent }) => ActorUnavailableError.make({
+	actor: parent.actor,
+	message: `computers are already kept for ${child.key}, which isn't stored, so the fork can't copy its own`
+});
+const copyInto = Effect.fnUntraced(function* copyInto(forking, held) {
+	const fs = yield* FileSystem.FileSystem;
+	const store = yield* storeOf(forking.root);
+	const directory = placeOf(store)(forking.child, "").actor;
+	if (yield* fs.exists(directory)) return yield* alreadyKept(forking);
+	yield* fs.makeDirectory(store.path.join(directory, markOf(forking.fork)), { recursive: true });
+	return yield* Effect.forEach(held, copied(store, forking), { discard: true });
+});
+/**
+* Copies the held computers into the child before it is published. The child's computers directory is marked with
+* the fork's id first, so a fork that never publishes leaves computers its retry or the next host start removes.
+*/
+const copyHeld = ({ held, ...forking }) => {
+	if (!Array.isReadonlyArrayNonEmpty(held)) return Effect.void;
+	return answered(forking.parent.actor)(copyInto(forking, held));
+};
+const released = (client, fork) => ({ name }) => unheld(client.resume(name, { hold: fork }));
+/** Lets go of the fork's holds: each computer returns where it was, a stopped one stopped. */
+const releaseParent = (client, fork, held) => Effect.forEach(held, released(client, fork), { discard: true });
+/** Every computer of the parent: a fork that crashed no longer knows which it held. */
+const everyComputer = (store, parent) => Effect.map(parentComputers(store, parent), Array.map(heldOf));
+const releaseHeld = Effect.fnUntraced(function* releaseHeld(store, forking, held) {
+	const client = yield* clientOf(forking.parent);
+	if (Option.isNone(client)) return;
+	const letGo = yield* Option.match(held, {
+		onNone: () => everyComputer(store, forking.parent),
+		onSome: Effect.succeed
+	});
+	yield* releaseParent(client.value, forking.fork, letGo);
+});
+/** Lets go of the parent's computers after a fork failed, keeping the mark so the child's copies are discarded. */
+const releaseComputers = ({ held, ...forking }) => answered(forking.parent.actor)(Effect.flatMap(storeOf(forking.root), (store) => releaseHeld(store, forking, held)));
+/**
+* Finishes a published fork's computers: removes the mark from the child's and lets go of the parent's. A retry of a
+* fork that crashed after publishing passes no `held`, so every computer is let go of.
+*/
+const settleComputers = ({ held, ...forking }) => answered(forking.parent.actor)(Effect.gen(function* settleFork() {
+	const fs = yield* FileSystem.FileSystem;
+	const store = yield* storeOf(forking.root);
+	const mark = store.path.join(placeOf(store)(forking.child, "").actor, markOf(forking.fork));
+	yield* fs.remove(mark, {
+		force: true,
+		recursive: true
+	});
+	yield* releaseHeld(store, forking, held);
+}));
+/** Removes the computers a fork that never published left for a child that isn't stored: only a marked directory. */
+const discardComputers = (forking) => answered(forking.parent.actor)(Effect.gen(function* discardChild() {
+	const fs = yield* FileSystem.FileSystem;
+	const store = yield* storeOf(forking.root);
+	const directory = placeOf(store)(forking.child, "").actor;
+	const names = yield* listed(directory);
+	if (Array.some(names, String$1.startsWith(markPrefix))) yield* fs.remove(directory, {
+		force: true,
+		recursive: true
+	});
+}));
+/** A stored child keeps its computers and loses the mark; a child that isn't stored loses its computers. */
+const sweptPath = (path, root, stored) => (entry) => {
+	const mark = path.join(root, entry);
+	const owner = path.dirname(mark);
+	if (stored.has(String$1.replaceAll(path.sep, "/")(path.relative(root, owner)))) return mark;
+	return owner;
+};
+/**
+* At a host's start, settles every mark crashed forks left on a child's computers. `storedActors` names each stored
+* actor as `<Actor>/<key segment>`, and is read only when a mark is found.
+*/
+const sweepComputers = Effect.fnUntraced(function* sweepComputers(root, storedActors) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	if (!(yield* fs.exists(root))) return;
+	const marks = yield* fs.glob(`*/*/${markPrefix}*/`, { root });
+	if (!Array.isReadonlyArrayNonEmpty(marks)) return;
+	const stored = yield* storedActors;
+	const swept = Array.map(marks, sweptPath(path, root, stored));
+	yield* Effect.forEach(swept, (removed) => fs.remove(removed, {
+		force: true,
+		recursive: true
+	}), { discard: true });
+});
+const make = Effect.gen(function* makeForkComputers() {
+	const services = yield* Effect.context();
+	return {
+		copy: (forking) => Effect.provideContext(copyHeld(forking), services),
+		discard: (forking) => Effect.provideContext(discardComputers(forking), services),
+		hold: (forking) => Effect.provideContext(holdParent(forking), services),
+		release: (forking) => Effect.provideContext(releaseComputers(forking), services),
+		settle: (forking) => Effect.provideContext(settleComputers(forking), services),
+		sweep: (root, storedActors) => Effect.provideContext(sweepComputers(root, storedActors), services)
+	};
+});
+/**
+* The computers of an actor fork on the local engine: `hold` the parent's before the cut, `copy` them into the child
+* before it is published, stopped, then `settle` once it is, or `release` after a failure, so `discard` finds the
+* copies to remove. `sweep` settles what crashed forks left when a host starts.
+*/
+var ForkComputers = class extends Context.Service()("@akterjs/effect/host/fork/fork-computers.adapter/ForkComputers") {
+	static layer = Layer.effect(this, make);
+};
+export { ForkComputers };

package/dist/host/hash/blob-hashing.service.d.mts

@@ -0,0 +1,10 @@
+import { Context, Effect } from "effect";
+interface BlobDigest {
+  readonly digest: Effect.Effect<string>;
+  readonly update: (bytes: Uint8Array) => Effect.Effect<void>;
+}
+declare const BlobHashing_base: Context.ServiceClass<BlobHashing, "@akterjs/effect/host/hash/blob-hashing.service/BlobHashing", {
+  readonly sha256: Effect.Effect<BlobDigest>;
+}>;
+export declare class BlobHashing extends BlobHashing_base {}
+export {};

package/dist/host/hash/blob-hashing.service.mjs

@@ -0,0 +1,4 @@
+import { Context } from "effect";
+// src/host/hash/blob-hashing.service.ts
+var BlobHashing = class extends Context.Service()("@akterjs/effect/host/hash/blob-hashing.service/BlobHashing") {};
+export { BlobHashing };

package/dist/host/job/job-durables.sql.d.mts

@@ -0,0 +1,44 @@
+import { ActorUnavailableError } from "../../contract/client/actor-unavailable.errors.mjs";
+import { JobAddress } from "../../contract/job/job-id.pure.mjs";
+import { StartedJob } from "../../contract/job/started-job.schema.mjs";
+import { Execution, JobStore, Runs } from "./job-runs.pure.mjs";
+import { Deferred, Effect, MutableHashMap, Scope } from "effect";
+import { WorkflowEngine } from "effect/workflow";
+/**
+ * The store of the session that has `address` open, opening the actor when no session has it. The actor stays
+ * resident until the scope closes, so a signal or poll from outside the job can't lose its session halfway. It fails
+ * with `ActorUnavailableError` when this host can't open the actor, such as when another host serves it.
+ */
+type Locate = (address: JobAddress) => Effect.Effect<JobStore, ActorUnavailableError, Scope.Scope>;
+type Encoded = WorkflowEngine.Encoded;
+interface Waiting {
+  readonly job: StartedJob;
+  readonly store: JobStore;
+}
+interface Engine extends Runs {
+  readonly locator: Deferred.Deferred<Locate>;
+  readonly waiting: MutableHashMap.MutableHashMap<string, Waiting>;
+}
+declare const storeOf: ({ engine, executionId }: {
+  readonly engine: Engine;
+  readonly executionId: string;
+}) => Effect.Effect<JobStore, never, Scope.Scope>;
+declare const executionOf: (engine: Engine) => Effect.Effect<Execution, never, WorkflowEngine.WorkflowInstance>;
+/**
+ * A signal comes from outside the job, so it locates the actor's current session and keeps it resident until the
+ * result is stored, instead of trusting the store a running execution was started with, whose session can close
+ * between the lookup and the write. `deferredDone` has no error channel, so a signal this host can't deliver dies
+ * with the locator's `ActorUnavailableError`, which names the actor and what to do.
+ */
+declare const doneDeferred: (engine: Engine) => Encoded["deferredDone"];
+declare const scheduleClock: (engine: Engine) => Encoded["scheduleClock"];
+declare const deferredResult: (engine: Engine) => Encoded["deferredResult"];
+/**
+ * Wakes this store's runs that wait on a deferred a committed command has since stored a result for (`Akter.signal`
+ * writes it with the command), once the command commits. Only the deferreds a run found empty are checked.
+ */
+declare const wakeSignalled: ({ engine, store }: {
+  readonly engine: Engine;
+  readonly store: JobStore;
+}) => Effect.Effect<void>;
+export { type Encoded, type Engine, type Locate, type Waiting, deferredResult, doneDeferred, executionOf, scheduleClock, storeOf, wakeSignalled };