@akterjs/effect 0.0.0-stage → 0.1.1

package/dist/runtime/local-file-clients.layer.mjs

@@ -0,0 +1,78 @@
+import { Akter } from "../contract/akter.service.mjs";
+import { ActorFileClients } from "../contract/file/file-client.adapter.mjs";
+import { BlobTransferError } from "../contract/file/blob-transfer.errors.mjs";
+import { FileNotFoundError } from "../contract/file/file-not-found.errors.mjs";
+import { filePathOf } from "../contract/file/file-path.pure.mjs";
+import { fileListingOf } from "../contract/file/file-listing.pure.mjs";
+import { filePage } from "../host/blob/reference/blob-file-page.sql.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { Array, Effect, Layer, Option, Stream } from "effect";
+// src/runtime/local-file-clients.layer.ts
+const noBytes = 0n;
+const outsideActor = Effect.flatMap(Effect.serviceOption(Akter), (actor) => {
+	if (Option.isSome(actor)) return Effect.fail(BlobTransferError.make({
+		blob: "",
+		message: "use the file client outside actor commands and queries, and Akter.files inside them"
+	}));
+	return Effect.void;
+});
+const uploadWith = ({ address, host }) => Effect.fnUntraced(function* upload(source) {
+	yield* outsideActor;
+	const { home, kick, owner } = yield* host.prepareFiles(address);
+	return yield* Effect.tap(home.transfers.upload({
+		owner,
+		source
+	}), () => kick);
+}, Effect.scoped);
+const downloadWith = ({ address, host }, path, range) => Stream.unwrap(Effect.gen(function* download() {
+	yield* outsideActor;
+	const valid = yield* filePathOf(path);
+	const found = yield* host.currentFiles(address);
+	if (Option.isNone(found)) return yield* FileNotFoundError.make({ path: valid });
+	const { home, owner } = found.value;
+	const link = yield* owner.exclusive(owner.transaction(owner.receipts.link(valid)));
+	const file = yield* Effect.mapError(Effect.fromOption(link), () => FileNotFoundError.make({ path: valid }));
+	const opening = {
+		actor: owner.actor,
+		blob: file.blob,
+		grant: file.grant
+	};
+	return Option.match(Option.fromNullishOr(range), {
+		onNone: () => home.transfers.open(opening),
+		onSome: (requested) => home.transfers.open({
+			...opening,
+			range: requested
+		})
+	});
+}));
+const pageWith = ({ address, host }, listing) => Effect.gen(function* list() {
+	yield* outsideActor;
+	const valid = yield* fileListingOf(listing);
+	const found = yield* host.currentFiles(address);
+	if (Option.isNone(found)) return {
+		cursor: Option.none(),
+		entries: []
+	};
+	const { owner, sql } = found.value;
+	return yield* owner.exclusive(owner.transaction(filePage({
+		actor: owner.actor,
+		listing: valid,
+		sql
+	})));
+}).pipe(Effect.scoped);
+const clientWith = (binding) => ({
+	download: (path, range) => downloadWith(binding, path, range),
+	fileUsage: (listing = {}) => Effect.map(pageWith(binding, listing), (page) => ({
+		...page,
+		bytes: Array.reduce(page.entries, noBytes, (total, file) => total + BigInt(file.bytes))
+	})),
+	list: (listing = {}) => pageWith(binding, listing),
+	upload: uploadWith(binding)
+});
+/** The file client of one actor on this host, outside its commands and queries. */
+const hostFileClient = clientWith;
+const localFileClients = Layer.effect(ActorFileClients, Effect.map(ActorHost, (host) => ({ connect: (address) => clientWith({
+	address,
+	host
+}) })));
+export { hostFileClient, localFileClients };

package/dist/runtime/local-job-runtime.layer.d.mts

@@ -0,0 +1,19 @@
+import { ActorSecrets } from "../contract/secret/actor-secrets.adapter.mjs";
+import { JobComputers } from "../host/computer/job-computers.service.mjs";
+import { JobEngine } from "../host/job/job-engine.adapter.mjs";
+import { Effect, FileSystem, Layer, Path } from "effect";
+import { ChildProcessSpawner } from "effect/process";
+/** What the local engine's computers run on: the disk and a process spawner. */
+type ComputerNeeds = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path;
+/** What binding the computers needs: the computers to bind, and what they run on. */
+type BinderNeeds = ComputerNeeds | JobComputers;
+/**
+ * The local engine's job runtime, for an app layer whose job handlers need the `WorkflowEngine`. Its job activities
+ * read their declared secrets from the current `ConfigProvider`: the process environment, as Bun loads it with `.env`.
+ * With `AKTER_LOCAL_COMPUTERS` on, they reach the computers of the store `Akter.local` serves through
+ * `Actor.computer(key)`, because both hold the same `JobComputers`, as they hold the same job engine.
+ */
+declare const jobs: Layer.Layer<ActorSecrets | JobComputers | JobEngine | import("effect/workflow/WorkflowEngine").WorkflowEngine, never, never>;
+/** Binds the app's job computers to local computers under each store the engine serves: its `computers` directory. */
+declare const computersBinder: () => Effect.Effect<(store: string) => Effect.Effect<void>, never, JobComputers | ComputerNeeds>;
+export { type BinderNeeds, type ComputerNeeds, computersBinder, jobs };

package/dist/runtime/local-job-runtime.layer.mjs

@@ -0,0 +1,21 @@
+import { ActorSecrets } from "../contract/secret/actor-secrets.adapter.mjs";
+import { JobComputers } from "../host/computer/job-computers.service.mjs";
+import { LocalComputers } from "../host/computer/local-computers.adapter.mjs";
+import { JobEngine } from "../host/job/job-engine.adapter.mjs";
+import { Effect, Layer, Path } from "effect";
+// src/runtime/local-job-runtime.layer.ts
+/**
+* The local engine's job runtime, for an app layer whose job handlers need the `WorkflowEngine`. Its job activities
+* read their declared secrets from the current `ConfigProvider`: the process environment, as Bun loads it with `.env`.
+* With `AKTER_LOCAL_COMPUTERS` on, they reach the computers of the store `Akter.local` serves through
+* `Actor.computer(key)`, because both hold the same `JobComputers`, as they hold the same job engine.
+*/
+const jobs = Layer.mergeAll(JobEngine.layerWorkflow, ActorSecrets.fromConfig, JobComputers.layer);
+/** Binds the app's job computers to local computers under each store the engine serves: its `computers` directory. */
+const computersBinder = Effect.fnUntraced(function* computersBinder() {
+	const computers = yield* JobComputers;
+	const services = yield* Effect.context();
+	const path = yield* Path.Path;
+	return (store) => Effect.flatMap(LocalComputers.make(path.join(store, "computers")), computers.bind).pipe(Effect.provideContext(services));
+});
+export { computersBinder, jobs };

package/dist/serve/archive/archived-actors.layer.d.mts

@@ -0,0 +1,17 @@
+import { BlobTransferError } from "../../contract/file/blob-transfer.errors.mjs";
+import "../hosted/hosted-runtime.layer.mjs";
+import { StoreUnreadableError } from "../store/store-unreadable.errors.mjs";
+import { Effect, FileSystem, Path } from "effect";
+export declare const ArchivedActors: {
+  readonly adopt: (folder: string) => Effect.Effect<void, BlobTransferError | import("effect/PlatformError").PlatformError | import("effect/sql/SqlError").SqlError | StoreUnreadableError, FileSystem.FileSystem | Path.Path>;
+  readonly lineage: (folder: string) => Effect.Effect<{
+    actor: {
+      key: string;
+      type: string;
+    };
+    fork: string;
+    forkedAt: number;
+    origin: string;
+  }[], import("effect/sql/SqlError").SqlError | StoreUnreadableError, FileSystem.FileSystem | Path.Path>;
+  readonly strip: (filename: string) => Effect.Effect<void, import("effect/sql/SqlError").SqlError, never>;
+};

package/dist/serve/archive/archived-actors.layer.mjs

@@ -0,0 +1,84 @@
+import { adoptArchivedFiles } from "../../host/blob/export/blob-archive.sql.mjs";
+import { lineageOf } from "../../host/fork/actor-fork.sql.mjs";
+import { stripArchivedFiles } from "../../host/blob/reference/blob-receipts.sql.mjs";
+import { LocalBlobHomes } from "../../host/file/local-blob-home.service.mjs";
+import { SqliteDriver } from "../../host/sqlite/sqlite-driver.service.mjs";
+import { blobHashing } from "../../runtime/blob-hashing.layer.mjs";
+import { ActorLocation } from "../engine/actor-location.service.mjs";
+import { fileIdentity } from "../engine/actor-residents.pure.mjs";
+import { Array, Context, Effect, FileSystem, Layer, Option, Path } from "effect";
+import { SecureRandom } from "effect/crypto";
+// src/serve/archive/archived-actors.layer.ts
+const filesFolder = "files";
+/**
+* Prepares an actor's database file for an `.akter` archive: every file grant blanked and the export holds dropped,
+* with the file rewritten so none of them stays in its free pages. Its state, history and file paths are unchanged.
+*/
+const strip = Effect.fnUntraced(function* stripArchived(filename) {
+	const services = yield* Layer.build(SqliteDriver.layerNode);
+	const sql = yield* Context.get(services, SqliteDriver).open(filename);
+	yield* stripArchivedFiles(sql);
+}, Effect.scoped);
+const adoptActor = Effect.fnUntraced(function* adoptActorFiles({ home, location, sqlite }, address) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const { database, directory } = location.locate(address);
+	const files = path.join(directory, filesFolder);
+	const sql = yield* sqlite.open(database);
+	yield* adoptArchivedFiles({
+		actor: fileIdentity(address),
+		adopt: home.transfers.adopt,
+		sql,
+		stored: (sha256) => fileSystem.stream(path.join(files, sha256))
+	});
+	yield* fileSystem.remove(files, {
+		force: true,
+		recursive: true
+	});
+}, Effect.scoped);
+/**
+* Takes the files of every actor in an imported folder into the folder's own file home, `files-home`, the one
+* `akter dev` opens: each actor's `files/<sha256>` is adopted under the actor's local identity, its database is
+* rewritten for it, and its `files/` folder is removed. Run it before anything serves the folder.
+*/
+const adopt = Effect.fnUntraced(function* adoptArchived(folder) {
+	const path = yield* Path.Path;
+	const services = yield* Layer.build(Layer.mergeAll(ActorLocation.directory(folder), SqliteDriver.layerNode, blobHashing, SecureRandom.layerWebCrypto));
+	const home = yield* Effect.provide(LocalBlobHomes.open(path.join(folder, "files-home")), services);
+	const location = Context.get(services, ActorLocation);
+	const actors = yield* location.list;
+	const adopting = {
+		home,
+		location,
+		sqlite: Context.get(services, SqliteDriver)
+	};
+	yield* Effect.forEach(actors, (address) => adoptActor(adopting, address), { discard: true });
+}, Effect.scoped);
+const forkOf = Effect.fnUntraced(function* forkOf(sqlite, directory) {
+	const path = yield* Path.Path;
+	const sql = yield* sqlite.open(path.join(directory, "actor.db"));
+	const recorded = yield* lineageOf(sql);
+	const actor = {
+		key: path.basename(directory),
+		type: path.basename(path.dirname(directory))
+	};
+	return Option.map(recorded, ({ forkId, origin, version }) => ({
+		actor,
+		fork: forkId,
+		forkedAt: version,
+		origin
+	}));
+}, Effect.scoped);
+const ArchivedActors = {
+	adopt,
+	lineage: Effect.fnUntraced(function* archivedLineage(folder) {
+		const services = yield* Layer.build(Layer.merge(ActorLocation.directory(folder), SqliteDriver.layerNode));
+		const location = Context.get(services, ActorLocation);
+		const sqlite = Context.get(services, SqliteDriver);
+		const actors = yield* location.list;
+		const forks = yield* Effect.forEach(actors, (address) => forkOf(sqlite, location.locate(address).directory));
+		return Array.getSomes(forks);
+	}, Effect.scoped),
+	strip
+};
+export { ArchivedActors };

package/dist/serve/archive/archived-store.layer.d.mts

@@ -0,0 +1,12 @@
+import { Effect, FileSystem, Path } from "effect";
+/**
+ * Whether a path in a data directory, relative and with `/` separators, belongs to its environments rather than to
+ * the serving store: the record and its journal files, every snapshot and every other environment's store. No
+ * archive holds them; an archive is one environment's export.
+ */
+declare const isEnvironmentEntry: (relative: string) => boolean;
+export declare const ArchivedStore: {
+  readonly isEnvironmentEntry: typeof isEnvironmentEntry;
+  readonly served: (folder: string) => Effect.Effect<string, import("effect/PlatformError").PlatformError | import("effect/sql/SqlError").SqlError, FileSystem.FileSystem | Path.Path>;
+};
+export {};

package/dist/serve/archive/archived-store.layer.mjs

@@ -0,0 +1,40 @@
+import { SqliteDriver } from "../../host/sqlite/sqlite-driver.service.mjs";
+import { environmentRow, recordFile, servingRow } from "../environment/environment-records.sql.mjs";
+import { Array, Context, Effect, FileSystem, Layer, Option, Path, String } from "effect";
+// src/serve/archive/archived-store.layer.ts
+/**
+* The store an `.akter` archive of `folder` holds: the environment its record says serves, the folder itself for
+* `dev` or `environments/<name>` for a promoted branch. A folder with no record, such as an export's staging folder,
+* is its own store. The record is read query-only, so a running `akter dev` is never disturbed.
+*/
+const served = Effect.fnUntraced(function* servedStore(folder) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const record = path.join(folder, recordFile);
+	if (!(yield* fileSystem.exists(record))) return folder;
+	const services = yield* Layer.build(SqliteDriver.layerNode);
+	const sql = yield* Context.get(services, SqliteDriver).openQueryOnly(record);
+	const serving = yield* servingRow({ sql });
+	const row = yield* environmentRow({
+		name: serving.environment,
+		sql
+	});
+	return path.resolve(folder, Option.match(row, {
+		onNone: () => ".",
+		onSome: (found) => found.directory
+	}));
+}, Effect.scoped);
+/**
+* Whether a path in a data directory, relative and with `/` separators, belongs to its environments rather than to
+* the serving store: the record and its journal files, every snapshot and every other environment's store. No
+* archive holds them; an archive is one environment's export.
+*/
+const isEnvironmentEntry = (relative) => {
+	const top = Option.getOrElse(Array.head(String.split("/")(relative)), () => relative);
+	return top === "environments" || top === "snapshots" || String.startsWith("environments.db")(top);
+};
+const ArchivedStore = {
+	isEnvironmentEntry,
+	served
+};
+export { ArchivedStore };

package/dist/serve/engine/actor-engine.layer.d.mts

@@ -0,0 +1,8 @@
+import { ActorJournal } from "../../contract/history/actor-journal.service.mjs";
+import { ActorRegistry } from "../../contract/actor/actor-registry.service.mjs";
+import { ActorHost } from "./actor-host.service.mjs";
+import { FileSystem, Layer, Path } from "effect";
+declare const providedHandlers: Layer.Layer<ActorRegistry, never, never>;
+declare const actorEngine: (directory: string) => Layer.Layer<ActorHost | ActorRegistry, never, FileSystem.FileSystem | Path.Path>;
+declare const hostJournal: Layer.Layer<ActorJournal, never, ActorHost>;
+export { actorEngine, hostJournal, providedHandlers };

package/dist/serve/engine/actor-engine.layer.mjs

@@ -0,0 +1,30 @@
+import { handlersKey } from "../../contract/actor/actor-definition.pure.mjs";
+import { ActorJournal } from "../../contract/history/actor-journal.service.mjs";
+import { ActorRegistry } from "../../contract/actor/actor-registry.service.mjs";
+import { ActorDatabase } from "../../host/actor/actor-database.service.mjs";
+import { CommandRunner } from "../../host/command/command-runner.service.mjs";
+import { ActorHost } from "./actor-host.service.mjs";
+import { ActorLocation } from "./actor-location.service.mjs";
+import { Context, Effect, Layer, Option } from "effect";
+// src/serve/engine/actor-engine.layer.ts
+const providedHandlers = Layer.effect(ActorRegistry, Effect.gen(function* findProvidedHandlers() {
+	const provided = yield* Effect.context();
+	const registered = yield* ActorRegistry.make;
+	return {
+		lookup: (name) => Option.match(Context.getOption(provided, handlersKey(name)), {
+			onNone: () => registered.lookup(name),
+			onSome: Effect.succeed
+		}),
+		register: registered.register
+	};
+}));
+const actorEngine = (directory) => ActorHost.layer.pipe(Layer.provideMerge(providedHandlers), Layer.provide([
+	ActorDatabase.layerNode,
+	ActorLocation.directory(directory),
+	CommandRunner.layer
+]), Layer.fresh);
+const hostJournal = Layer.effect(ActorJournal, ActorHost.use((host) => Effect.succeed({
+	coveredSince: host.coveredSince,
+	read: host.history
+})));
+export { actorEngine, hostJournal, providedHandlers };

package/dist/serve/engine/actor-fork.service.d.mts

@@ -0,0 +1,63 @@
+import { ActorAlreadyExistsError } from "../../contract/actor/actor-already-exists.errors.mjs";
+import { ActorErasedError } from "../../contract/actor/actor-erased.errors.mjs";
+import { ActorNotCreatedError } from "../../contract/actor/actor-not-created.errors.mjs";
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import { ForkedFiles } from "../../host/fork/actor-fork.sql.mjs";
+import "../../contract/client/client-failure.contract.mjs";
+import { StoreUnreadableError } from "../store/store-unreadable.errors.mjs";
+import { ActorDatabase, OpenedActor } from "../../host/actor/actor-database.service.mjs";
+import { LocalBlobHomes } from "../../host/file/local-blob-home.service.mjs";
+import { ForkComputers } from "../../host/fork/fork-computers.adapter.mjs";
+import { ActorAddress, ActorLocation, StagedFork } from "./actor-location.service.mjs";
+import { OpenFailure, Residents } from "./actor-residents.pure.mjs";
+import { Context, Effect, FileSystem, Option, Semaphore } from "effect";
+interface ForkCall extends ActorAddress {
+  readonly commandId: string;
+  readonly into: string;
+}
+interface ForkResident {
+  readonly exclusive: <Success, Failure, Needs>(effect: Effect.Effect<Success, Failure, Needs>) => Effect.Effect<Success, Failure, Needs>;
+  readonly forking: Semaphore.Semaphore;
+  readonly opened: OpenedActor;
+}
+/** What the fork needs from the host that runs it. */
+interface ForkHost<Resident extends ForkResident> {
+  readonly identity: (address: ActorAddress) => string;
+  readonly residents: Residents<Resident>;
+  readonly served: (address: ActorAddress) => Effect.Effect<OpenedActor["actor"], OpenFailure>;
+  readonly stored: (address: ActorAddress) => Effect.Effect<boolean, OpenFailure>;
+}
+type ForkFailure = ActorAlreadyExistsError | ActorNotCreatedError | InvalidRequestError | OpenFailure;
+type ForkServices = ActorDatabase | ActorLocation | FileSystem.FileSystem | ForkComputers;
+/**
+ * Forks actors on one host. Forks run one at a time, so two forks can't both find a child key free and publish into
+ * it; each holds its parent's fork gate from the cut until the child has its files, and holds the child's address
+ * from the check that it's free until the copy is renamed into place, so no command or upload creates the child
+ * meanwhile.
+ */
+declare const forkedBy: <Resident extends ForkResident>(host: ForkHost<Resident>) => ((call: ForkCall) => Effect.Effect<number, ForkFailure, ForkServices>);
+/** The file fork a staged copy began, if it was quieted as this fork and its files were forked. */
+declare const forkedIn: (args_0: StagedFork) => Effect.Effect<Option.None<ForkedFiles> | Option.Some<ForkedFiles>, import("effect/PlatformError").PlatformError | (ActorErasedError | import("effect/sql/SqlError").SqlError), ActorDatabase | FileSystem.FileSystem>;
+type SweepFailure = Effect.Error<ReturnType<typeof forkedIn>> | Effect.Error<LocalBlobHomes["Service"]["get"]>;
+/**
+ * Sweeps what forks that crashed before publishing left, when a host starts and before it forks or opens an actor:
+ * each staged copy, and the claims it took for a child that isn't stored and whose catalog row names the fork's
+ * parent. A retry of such a fork rebuilds it from its parent's intent.
+ */
+declare const sweepStaged: (identity: (address: ActorAddress) => string) => Effect.Effect<void, StoreUnreadableError | SweepFailure, ForkServices>;
+declare const ActorForks_base: Context.ServiceClass<ActorForks, "@akterjs/effect/serve/engine/actor-fork.service/ActorForks", {
+  readonly computers: typeof ForkComputers.layer;
+  readonly forkedBy: typeof forkedBy;
+  readonly sweepStaged: typeof sweepStaged;
+}>;
+/**
+ * Forks a stored actor into a new key at a cut between two of its commits. `forkedBy(host)` makes the fork route of
+ * one host; the copy starts quiet and is published by one rename. `sweepStaged` clears what crashed forks left.
+ */
+export declare class ActorForks extends ActorForks_base {
+  static readonly forkedBy: typeof forkedBy;
+  static readonly sweepStaged: (identity: (address: ActorAddress) => string) => Effect.Effect<void, StoreUnreadableError | SweepFailure, ForkServices>;
+  /** The fork's computers, which the host provides to its fork route and its sweep. */
+  static readonly computers: import("effect/Layer").Layer<ForkComputers, never, FileSystem.FileSystem | import("effect/Path").Path>;
+}
+export type { ForkCall, ForkFailure, ForkResident, ForkServices };

package/dist/serve/engine/actor-fork.service.mjs

@@ -0,0 +1,277 @@
+import { ActorAlreadyExistsError } from "../../contract/actor/actor-already-exists.errors.mjs";
+import { ActorNotCreatedError } from "../../contract/actor/actor-not-created.errors.mjs";
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import "../../contract/client/client-failure.contract.mjs";
+import { ActorDatabase } from "../../host/actor/actor-database.service.mjs";
+import { LocalBlobHomes } from "../../host/file/local-blob-home.service.mjs";
+import { ForkComputers } from "../../host/fork/fork-computers.adapter.mjs";
+import { forkIdOf, forkedFiles, markPublished, prepareForks, quietCopy, recordIntent, recordedFork } from "../../host/fork/actor-fork.sql.mjs";
+import { committedVersion } from "../live/live-tables.sql.mjs";
+import { ActorLocation } from "./actor-location.service.mjs";
+import { unavailable } from "./actor-residents.pure.mjs";
+import { Array, Context, Effect, FileSystem, Option, Semaphore } from "effect";
+// src/serve/engine/actor-fork.service.ts
+const oneFork = 1;
+const reused = ({ actor, commandId }) => InvalidRequestError.make({
+	actor,
+	message: `the fork id ${commandId} already forked this actor into another key`
+});
+/** The fork the parent recorded under this id, if any; the same id can't name a fork into another key. */
+const recorded = Effect.fnUntraced(function* recorded({ call, resident }) {
+	const { sql } = resident.opened;
+	const found = yield* resident.exclusive(Effect.andThen(prepareForks(sql), recordedFork({
+		commandId: call.commandId,
+		sql
+	})));
+	if (Option.isSome(found) && found.value.child !== call.into) return yield* reused(call);
+	return found;
+});
+/** The fork's computers: the parent's, copied into the child under the store's computers directory. */
+const computersOf = ({ call, child }) => ActorLocation.use((location) => Effect.succeed({
+	child,
+	fork: call.commandId,
+	parent: {
+		actor: call.actor,
+		key: call.key
+	},
+	root: location.computers
+}));
+/** Whether the child is already this fork's, published before a crash or a lost reply; any other child refuses. */
+const publishedChild = Effect.fnUntraced(function* publishedChild({ call, child, host }) {
+	if (!(yield* host.stored(child))) return false;
+	const { database } = yield* ActorLocation.use((location) => Effect.succeed(location.locate(child)));
+	const databases = yield* ActorDatabase;
+	const forkId = yield* Effect.scoped(Effect.flatMap(databases.openCopy(database), forkIdOf));
+	if (Option.contains(forkId, call.commandId)) return true;
+	return yield* ActorAlreadyExistsError.make({ actor: call.actor });
+});
+/**
+* Removes what an unfinished attempt of this fork left: its staged copy, and the files it claimed for the child. A
+* child that is stored keeps its claims, and so does one whose catalog row doesn't name this parent: either is an
+* actor of its own. Akter dev keeps every actor's files in one home, so the parent's home is the child's.
+*/
+const discardStaged = Effect.fnUntraced(function* discardStaged(forking) {
+	const { call, child, host, resident, staged } = forking;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const files = Option.fromNullishOr(resident.opened.fileSession);
+	const stored = yield* host.stored(child);
+	if (Option.isSome(files) && !stored) yield* files.value.home.catalog.abandon({
+		actor: host.identity(child),
+		origin: host.identity(call)
+	});
+	if (!stored) {
+		const computers = yield* computersOf(forking);
+		yield* ForkComputers.use((forked) => forked.discard(computers));
+	}
+	yield* fileSystem.remove(staged.directory, {
+		force: true,
+		recursive: true
+	});
+});
+/** Copies the parent at one cut between two of its commands, after recording the fork's intent. */
+const cut = Effect.fnUntraced(function* cut({ call, resident, staged }) {
+	const { sql } = resident.opened;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const cutParent = Effect.gen(function* cutParent() {
+		const version = yield* committedVersion(sql);
+		yield* recordIntent({
+			commandId: call.commandId,
+			into: call.into,
+			sql,
+			version
+		});
+		yield* fileSystem.makeDirectory(staged.directory, { recursive: true });
+		yield* sql`VACUUM INTO ${staged.database}`;
+		return version;
+	});
+	return yield* resident.exclusive(cutParent);
+});
+const quiet = Effect.fnUntraced(function* quiet({ call, staged }, version) {
+	const databases = yield* ActorDatabase;
+	const lineage = {
+		forkId: call.commandId,
+		origin: ActorLocation.named(call),
+		version
+	};
+	yield* Effect.scoped(Effect.flatMap(databases.openCopy(staged.database), (sql) => quietCopy({
+		...lineage,
+		sql
+	})));
+});
+const unavailableBy = (actor) => (failure) => unavailable(actor)({ message: `the fork didn't finish: ${failure.message}` });
+/** Inherits the parent's files at the cut into the staged child, under the child's own claims and grants. */
+const forkFiles = Effect.fnUntraced(function* forkFiles({ call, child, host, resident, staged }) {
+	const files = Option.fromNullishOr(resident.opened.fileSession);
+	if (Option.isNone(files)) return;
+	const actor = yield* host.served(child);
+	const databases = yield* ActorDatabase;
+	const opening = {
+		actor,
+		filename: staged.database,
+		identity: host.identity(child)
+	};
+	yield* Effect.scoped(Effect.gen(function* inheritFiles() {
+		const opened = yield* Effect.mapError(databases.open(opening), unavailableBy(call.actor));
+		const target = yield* Effect.orDie(Effect.fromNullishOr(opened.fileSession));
+		const source = files.value;
+		yield* source.home.transfers.fork({
+			into: target.home,
+			operation: call.commandId,
+			source: source.owner,
+			target: target.owner
+		});
+	}));
+});
+const publish = Effect.fnUntraced(function* publish({ call, child, resident, staged }) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const { directory } = yield* ActorLocation.use((location) => Effect.succeed(location.locate(child)));
+	yield* fileSystem.rename(staged.directory, directory);
+	yield* resident.exclusive(markPublished({
+		commandId: call.commandId,
+		sql: resident.opened.sql
+	}));
+});
+const copy = Effect.fnUntraced(function* copy(forking, computers, held) {
+	const version = yield* cut(forking);
+	yield* quiet(forking, version);
+	yield* forkFiles(forking);
+	yield* ForkComputers.use((forked) => forked.copy({
+		...computers,
+		held
+	}));
+	yield* publish(forking);
+	return version;
+});
+/**
+* Builds the child: holds the parent's computers, so none changes from before the cut until the child has its copy
+* of each, cuts and copies, publishes, then lets go of them. A failure lets go of them too.
+*/
+const build = Effect.fnUntraced(function* build(forking) {
+	yield* discardStaged(forking);
+	const computers = yield* computersOf(forking);
+	const forked = yield* ForkComputers;
+	const held = yield* forked.hold(computers);
+	const releasing = {
+		...computers,
+		held: Option.some(held)
+	};
+	const released = Effect.ignore(forked.release(releasing));
+	const version = yield* Effect.onError(copy(forking, computers, held), () => released);
+	yield* forked.settle(releasing);
+	return version;
+});
+/** Lets go of the parent's computers again for a fork its parent or child shows published before a crash. */
+const settledAgain = (forking) => Effect.flatMap(Effect.all([computersOf(forking), ForkComputers]), ([computers, forked]) => forked.settle({
+	...computers,
+	held: Option.none()
+}));
+/**
+* One fork, under the parent's fork gate so no command commits between the cut and the copy of its files. A fork the
+* parent already published answers its version again. Otherwise the child is built beside its directory and appears
+* by one rename, so nothing reads a partial child; a failed attempt removes what it built, and a retry rebuilds it.
+*/
+const forkHeld = Effect.fnUntraced(function* forkHeld(forking) {
+	const found = yield* recorded(forking);
+	const settled = settledAgain(forking);
+	if (Option.isSome(found) && found.value.state === "published") {
+		yield* settled;
+		return found.value.version;
+	}
+	if (yield* publishedChild(forking)) {
+		yield* forking.resident.exclusive(markPublished({
+			commandId: forking.call.commandId,
+			sql: forking.resident.opened.sql
+		}));
+		yield* settled;
+		return yield* Effect.map(Effect.orDie(Effect.fromOption(found)), (record) => record.version);
+	}
+	return yield* build(forking).pipe(Effect.onError(() => Effect.ignore(discardStaged(forking))));
+});
+/** The one copy a fork makes, answered as a fork's failures: a storage or file failure is a retryable unavailable. */
+const forkOnce = Effect.fnUntraced(function* forkOnce(forking) {
+	const unfinished = unavailableBy(forking.call.actor);
+	return yield* forkHeld(forking).pipe(Effect.catchTags({
+		BlobTransferError: (failure) => Effect.fail(unfinished(failure)),
+		PlatformError: (failure) => Effect.fail(unfinished(failure)),
+		SqlError: (failure) => Effect.fail(unfinished(failure))
+	}));
+});
+/**
+* Forks actors on one host. Forks run one at a time, so two forks can't both find a child key free and publish into
+* it; each holds its parent's fork gate from the cut until the child has its files, and holds the child's address
+* from the check that it's free until the copy is renamed into place, so no command or upload creates the child
+* meanwhile.
+*/
+const forkedBy = (host) => {
+	const serial = Semaphore.makeUnsafe(oneFork);
+	return Effect.fnUntraced(function* forkActor(call) {
+		const child = {
+			actor: call.actor,
+			key: call.into
+		};
+		if (call.into === call.key) return yield* InvalidRequestError.make({
+			actor: call.actor,
+			message: "an actor can't fork into itself"
+		});
+		if (!(yield* host.stored(call))) return yield* ActorNotCreatedError.make({ actor: call.actor });
+		const staged = yield* ActorLocation.use((location) => Effect.succeed(location.stage({
+			address: child,
+			fork: call.commandId
+		})));
+		return yield* serial.withPermits(oneFork)(host.residents.use(call, (resident) => forkOnce({
+			call,
+			child,
+			host,
+			resident,
+			staged
+		}).pipe(host.residents.holding(child), resident.forking.withPermits(oneFork))));
+	});
+};
+/** The file fork a staged copy began, if it was quieted as this fork and its files were forked. */
+const forkedIn = Effect.fnUntraced(function* forkedIn({ files, fork }) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const databases = yield* ActorDatabase;
+	if (!(yield* fileSystem.exists(files.database))) return Option.none();
+	const read = Effect.flatMap(databases.openCopy(files.database), (sql) => Effect.flatMap(forkIdOf(sql), (forkId) => {
+		if (!Option.contains(forkId, fork)) return Effect.succeedNone;
+		return forkedFiles(sql);
+	}));
+	return yield* Effect.scoped(read);
+});
+const sweepWith = (homes, stored) => Effect.fnUntraced(function* sweepOne(staged) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const forked = yield* forkedIn(staged);
+	const claimed = Option.filter(forked, (files) => !stored.has(files.actor));
+	if (Option.isSome(claimed) && Option.isSome(homes)) yield* (yield* homes.value.get).catalog.abandon(claimed.value);
+	yield* fileSystem.remove(staged.files.directory, {
+		force: true,
+		recursive: true
+	});
+});
+/**
+* Sweeps what forks that crashed before publishing left, when a host starts and before it forks or opens an actor:
+* each staged copy, and the claims it took for a child that isn't stored and whose catalog row names the fork's
+* parent. A retry of such a fork rebuilds it from its parent's intent.
+*/
+const sweepStaged = Effect.fnUntraced(function* sweepStaged(identity) {
+	const location = yield* ActorLocation;
+	const staged = yield* location.staged;
+	const named = Effect.map(location.list, (actors) => new Set(Array.map(actors, ActorLocation.named)));
+	yield* ForkComputers.use((forked) => forked.sweep(location.computers, named));
+	if (!Array.isReadonlyArrayNonEmpty(staged)) return;
+	const actors = yield* location.list;
+	const stored = new Set(Array.map(actors, identity));
+	const homes = yield* Effect.serviceOption(LocalBlobHomes);
+	yield* Effect.forEach(staged, sweepWith(homes, stored), { discard: true });
+});
+/**
+* Forks a stored actor into a new key at a cut between two of its commits. `forkedBy(host)` makes the fork route of
+* one host; the copy starts quiet and is published by one rename. `sweepStaged` clears what crashed forks left.
+*/
+var ActorForks = class extends Context.Service()("@akterjs/effect/serve/engine/actor-fork.service/ActorForks") {
+	static forkedBy = forkedBy;
+	static sweepStaged = sweepStaged;
+	/** The fork's computers, which the host provides to its fork route and its sweep. */
+	static computers = ForkComputers.layer;
+};
+export { ActorForks };