@akterjs/effect 0.0.0-stage → 0.1.1

package/dist/runtime/akter.layer.d.mts

@@ -0,0 +1,91 @@
+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 { Akter as Akter$1 } from "../contract/akter.service.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { ActorsNotHostedError } from "../serve/engine/actors-not-hosted.errors.mjs";
+import { ListenerNotLoopbackError } from "../serve/rpc/listener-not-loopback.errors.mjs";
+import { ServeOptions } from "../serve/rpc/akter-server.layer.mjs";
+import { environments, historyRetention, local, migrate } from "./akter-local.layer.mjs";
+import { ActorJournal, HistoryOptions } from "../contract/history/actor-journal.service.mjs";
+import { Branching, LocalEnvironments } from "../serve/environment/local-environments.service.mjs";
+import { Snapshotting } from "../serve/environment/snapshot-operations.sql.mjs";
+import { EnvironmentName, LocalEnvironment, LocalSnapshot, Promotion, SnapshotName } from "../serve/environment/local-environment.schema.mjs";
+import { AlreadyExistsError } from "../serve/environment/environment-already-exists.errors.mjs";
+import { InUseError } from "../serve/environment/environment-in-use.errors.mjs";
+import { NotFoundError } from "../serve/environment/environment-not-found.errors.mjs";
+import { LocalActorEngineServices } from "./local-actor-engine.layer.mjs";
+import { HostedAppBuildError } from "../serve/hosted/hosted-app-build.errors.mjs";
+import { MigrationHasher } from "../host/migration/migration-hasher.adapter.mjs";
+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 { ActorNotRegisteredError } from "../contract/actor/actor-not-registered.errors.mjs";
+import { ActorUnavailableError } from "../contract/client/actor-unavailable.errors.mjs";
+import { CallerNotAllowedError } from "../contract/caller/caller-not-allowed.errors.mjs";
+import { CommandIdExpiredError } from "../contract/command/command-id-expired.errors.mjs";
+import { CheckpointExpiredError } from "../contract/computer/checkpoint-expired.errors.mjs";
+import { ComputerHeldError } from "../contract/computer/computer-held.errors.mjs";
+import { HistoryEntry, RecordedCommand, UnreadableCommand } from "../contract/history/history-entry.pure.mjs";
+import { ComputerLimitError } from "../contract/computer/computer-limit.errors.mjs";
+import { ComputerLostError } from "../contract/computer/computer-lost.errors.mjs";
+import { ComputerNotFoundError } from "../contract/computer/computer-not-found.errors.mjs";
+import { ComputersUnavailableError } from "../contract/computer/computers-unavailable.errors.mjs";
+import { StepNotFoundError } from "../contract/computer/step/step-not-found.errors.mjs";
+import { FileAccessDeniedError } from "../contract/file/access/file-access-denied.errors.mjs";
+import { FileNotFoundError } from "../contract/file/file-not-found.errors.mjs";
+import { FileTooLargeError } from "../contract/file/rpc/file-too-large.errors.mjs";
+import { BlobTransferError } from "../contract/file/blob-transfer.errors.mjs";
+import { FilesUnavailableError } from "../contract/file/files-unavailable.errors.mjs";
+import { HandlerFailedError } from "../contract/hosted/handler-failed.errors.mjs";
+import { InvalidFileRequestError } from "../contract/file/invalid-file-request.errors.mjs";
+import { InvalidRequestError } from "../contract/client/invalid-request.errors.mjs";
+import { BillingUnavailableError } from "../contract/spend/billing-unavailable.errors.mjs";
+import { SpendCapReachedError } from "../contract/spend/spend-cap-reached.errors.mjs";
+import { StorageLimitError } from "../contract/client/storage-limit.errors.mjs";
+import { ReservedMemberError } from "../contract/actor/reserved-member.errors.mjs";
+import { ServedActor } from "../serve/rpc/actor-rpc.handlers.mjs";
+import { ReservedPayloadFieldError } from "../contract/job/reserved-payload-field.errors.mjs";
+import { StateUnreadableError } from "../contract/state/state-unreadable.errors.mjs";
+import { InvalidSecretNameError } from "../contract/secret/invalid-secret-name.errors.mjs";
+import { SecretUnavailableError } from "../contract/secret/secret-unavailable.errors.mjs";
+import { UnauthenticatedError } from "../contract/caller/unauthenticated.errors.mjs";
+import { CommandRejectedError } from "../host/command/command-rejected.errors.mjs";
+import { LayoutVersionError } from "../host/layout/layout-version.errors.mjs";
+import { MigrationEditedError } from "../host/migration/migration-edited.errors.mjs";
+import { MigrationFailedError } from "../host/migration/migration-failed.errors.mjs";
+import { localClient } from "../serve/rpc/in-process-client.layer.mjs";
+import { MigrationMissingError } from "../host/migration/migration-missing.errors.mjs";
+import { ReservedNameError } from "../host/actor/reserved-name.errors.mjs";
+import { HistoryPrunedError } from "../host/command/history-pruned.errors.mjs";
+import { CommandIdReusedError } from "../host/command/command-id-reused.errors.mjs";
+import { ReplayCursorStalledError } from "../host/command/replay/replay-cursor-stalled.errors.mjs";
+import { ActorNotMigratedError } from "../serve/store/actor-not-migrated.errors.mjs";
+import { StoreUnreadableError } from "../serve/store/store-unreadable.errors.mjs";
+import { ReplaySource, Verify, VerifyFailure } from "../serve/verify/verify.layer.mjs";
+import { JournalPoint, ReplayDifference, ReplayFailure, ReplayReport, ReplayWindow, ReplayedOutcome } from "../host/command/command-replay.service.mjs";
+import { LocalMigration, MigratedActor } from "../serve/store/store-migrations.service.mjs";
+import { Layer } from "effect";
+import { HttpServer, HttpServerError } from "effect/http";
+interface InspectorOptions {
+  readonly allowedHosts?: readonly string[] | true;
+  readonly directory: string;
+  readonly port?: number;
+}
+export declare class Akter extends Akter$1 {
+  /** A data directory's environments and snapshots, read and changed without running an engine on it. */
+  static readonly environments: typeof environments;
+  static readonly historyRetention: typeof historyRetention;
+  /**
+   * The local engine's job runtime. Provide it under an app layer whose job handlers need the `WorkflowEngine`,
+   * beside `Akter.local`, so the handlers register on the engine that runs their jobs:
+   * `Akter.local(directory).pipe(Layer.provide(app.layer), Layer.provide(Akter.jobs))`.
+   */
+  static readonly jobs: Layer.Layer<ActorSecrets | JobComputers | JobEngine | import("effect/workflow/WorkflowEngine").WorkflowEngine, never, never>;
+  static readonly local: typeof local;
+  static readonly localClient: typeof localClient;
+  static inspector(options: InspectorOptions): Layer.Layer<HttpServer.HttpServer, HttpServerError.ServeError>;
+  static readonly migrate: typeof migrate;
+  static serve<const Actors extends readonly ServedActor[]>(options: ServeOptions<Actors>): Layer.Layer<HttpServer.HttpServer, ActorsNotHostedError | HttpServerError.ServeError | ListenerNotLoopbackError, ActorHost>;
+}
+export { ActorAlreadyExistsError, ActorErasedError, ActorHost, ActorJournal, ActorNotCreatedError, ActorNotMigratedError, ActorNotRegisteredError, ActorUnavailableError, ActorsNotHostedError, AlreadyExistsError, BillingUnavailableError, BlobTransferError, type Branching, CallerNotAllowedError, CheckpointExpiredError, CommandIdExpiredError, CommandIdReusedError, CommandRejectedError, ComputerHeldError, ComputerLimitError, ComputerLostError, ComputerNotFoundError, ComputersUnavailableError, EnvironmentName, FileAccessDeniedError, FileNotFoundError, FileTooLargeError, FilesUnavailableError, HandlerFailedError, type HistoryEntry, type HistoryOptions, HistoryPrunedError, HostedAppBuildError, InUseError, InvalidFileRequestError, InvalidRequestError, InvalidSecretNameError, type JournalPoint, LayoutVersionError, ListenerNotLoopbackError, type LocalActorEngineServices, LocalEnvironment, LocalEnvironments, type LocalMigration, LocalSnapshot, type MigratedActor, MigrationEditedError, MigrationFailedError, MigrationHasher, MigrationMissingError, NotFoundError, Promotion, type RecordedCommand, ReplayCursorStalledError, type ReplayDifference, type ReplayFailure, type ReplayReport, type ReplaySource, type ReplayWindow, type ReplayedOutcome, ReservedMemberError, ReservedNameError, ReservedPayloadFieldError, SecretUnavailableError, SnapshotName, type Snapshotting, SpendCapReachedError, StateUnreadableError, StepNotFoundError, StorageLimitError, StoreUnreadableError, UnauthenticatedError, type UnreadableCommand, Verify, type VerifyFailure };

package/dist/runtime/akter.layer.mjs

@@ -0,0 +1,99 @@
+import { Akter as Akter$1 } from "../contract/akter.service.mjs";
+import { serveInspector } from "../serve/inspect/inspector.layer.mjs";
+import { serve } from "../serve/rpc/akter-server.layer.mjs";
+import { environments, historyRetention, local, migrate } from "./akter-local.layer.mjs";
+import { httpServer } from "./http-server.layer.mjs";
+import { ActorJournal } from "../contract/history/actor-journal.service.mjs";
+import { LocalEnvironments } from "../serve/environment/local-environments.service.mjs";
+import { EnvironmentName, LocalEnvironment, LocalSnapshot, Promotion, SnapshotName } from "../serve/environment/local-environment.schema.mjs";
+import { AlreadyExistsError } from "../serve/environment/environment-already-exists.errors.mjs";
+import { InUseError } from "../serve/environment/environment-in-use.errors.mjs";
+import { NotFoundError } from "../serve/environment/environment-not-found.errors.mjs";
+import { HostedAppBuildError } from "../serve/hosted/hosted-app-build.errors.mjs";
+import { MigrationHasher } from "../host/migration/migration-hasher.adapter.mjs";
+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 { ActorNotRegisteredError } from "../contract/actor/actor-not-registered.errors.mjs";
+import { ActorUnavailableError } from "../contract/client/actor-unavailable.errors.mjs";
+import { CallerNotAllowedError } from "../contract/caller/caller-not-allowed.errors.mjs";
+import { CommandIdExpiredError } from "../contract/command/command-id-expired.errors.mjs";
+import { CheckpointExpiredError } from "../contract/computer/checkpoint-expired.errors.mjs";
+import { ComputerHeldError } from "../contract/computer/computer-held.errors.mjs";
+import { ComputerLimitError } from "../contract/computer/computer-limit.errors.mjs";
+import { ComputerLostError } from "../contract/computer/computer-lost.errors.mjs";
+import { ComputerNotFoundError } from "../contract/computer/computer-not-found.errors.mjs";
+import { ComputersUnavailableError } from "../contract/computer/computers-unavailable.errors.mjs";
+import { StepNotFoundError } from "../contract/computer/step/step-not-found.errors.mjs";
+import { FileAccessDeniedError } from "../contract/file/access/file-access-denied.errors.mjs";
+import { FileNotFoundError } from "../contract/file/file-not-found.errors.mjs";
+import { FileTooLargeError } from "../contract/file/rpc/file-too-large.errors.mjs";
+import { BlobTransferError } from "../contract/file/blob-transfer.errors.mjs";
+import { FilesUnavailableError } from "../contract/file/files-unavailable.errors.mjs";
+import { HandlerFailedError } from "../contract/hosted/handler-failed.errors.mjs";
+import { InvalidFileRequestError } from "../contract/file/invalid-file-request.errors.mjs";
+import { InvalidRequestError } from "../contract/client/invalid-request.errors.mjs";
+import { BillingUnavailableError } from "../contract/spend/billing-unavailable.errors.mjs";
+import { SpendCapReachedError } from "../contract/spend/spend-cap-reached.errors.mjs";
+import { StorageLimitError } from "../contract/client/storage-limit.errors.mjs";
+import { ReservedMemberError } from "../contract/actor/reserved-member.errors.mjs";
+import { ReservedPayloadFieldError } from "../contract/job/reserved-payload-field.errors.mjs";
+import { StateUnreadableError } from "../contract/state/state-unreadable.errors.mjs";
+import { InvalidSecretNameError } from "../contract/secret/invalid-secret-name.errors.mjs";
+import { SecretUnavailableError } from "../contract/secret/secret-unavailable.errors.mjs";
+import { UnauthenticatedError } from "../contract/caller/unauthenticated.errors.mjs";
+import { CommandRejectedError } from "../host/command/command-rejected.errors.mjs";
+import { LayoutVersionError } from "../host/layout/layout-version.errors.mjs";
+import { MigrationEditedError } from "../host/migration/migration-edited.errors.mjs";
+import { MigrationFailedError } from "../host/migration/migration-failed.errors.mjs";
+import { MigrationMissingError } from "../host/migration/migration-missing.errors.mjs";
+import { jobs } from "./local-job-runtime.layer.mjs";
+import { ReservedNameError } from "../host/actor/reserved-name.errors.mjs";
+import { HistoryPrunedError } from "../host/command/history-pruned.errors.mjs";
+import { CommandIdReusedError } from "../host/command/command-id-reused.errors.mjs";
+import { ReplayCursorStalledError } from "../host/command/replay/replay-cursor-stalled.errors.mjs";
+import { localClient } from "../serve/rpc/in-process-client.layer.mjs";
+import { ActorNotMigratedError } from "../serve/store/actor-not-migrated.errors.mjs";
+import { ActorsNotHostedError } from "../serve/engine/actors-not-hosted.errors.mjs";
+import { ListenerNotLoopbackError } from "../serve/rpc/listener-not-loopback.errors.mjs";
+import { StoreUnreadableError } from "../serve/store/store-unreadable.errors.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { Verify } from "../serve/verify/verify.layer.mjs";
+import { Layer, String } from "effect";
+// src/runtime/akter.layer.ts
+const defaultPort = 4e3;
+const loopback = "127.0.0.1";
+const bracketed = /^\[(?<address>.*)\]$/u;
+const defaultInspectorPort = 4001;
+var Akter = class extends Akter$1 {
+	/** A data directory's environments and snapshots, read and changed without running an engine on it. */
+	static environments = environments;
+	static historyRetention = historyRetention;
+	/**
+	* The local engine's job runtime. Provide it under an app layer whose job handlers need the `WorkflowEngine`,
+	* beside `Akter.local`, so the handlers register on the engine that runs their jobs:
+	* `Akter.local(directory).pipe(Layer.provide(app.layer), Layer.provide(Akter.jobs))`.
+	*/
+	static jobs = jobs;
+	static local = local;
+	static localClient = localClient;
+	static inspector(options) {
+		const listener = {
+			hostname: loopback,
+			port: options.port ?? defaultInspectorPort
+		};
+		return serveInspector({
+			allowedHosts: options.allowedHosts ?? [],
+			directory: options.directory
+		}).pipe(Layer.provideMerge(httpServer(listener)));
+	}
+	static migrate = migrate;
+	static serve(options) {
+		const listener = {
+			hostname: String.replace(bracketed, "$<address>")(options.hostname ?? loopback),
+			port: options.port ?? defaultPort
+		};
+		return serve(options).pipe(Layer.provideMerge(httpServer(listener)));
+	}
+};
+export { ActorAlreadyExistsError, ActorErasedError, ActorHost, ActorJournal, ActorNotCreatedError, ActorNotMigratedError, ActorNotRegisteredError, ActorUnavailableError, ActorsNotHostedError, Akter, AlreadyExistsError, BillingUnavailableError, BlobTransferError, CallerNotAllowedError, CheckpointExpiredError, CommandIdExpiredError, CommandIdReusedError, CommandRejectedError, ComputerHeldError, ComputerLimitError, ComputerLostError, ComputerNotFoundError, ComputersUnavailableError, EnvironmentName, FileAccessDeniedError, FileNotFoundError, FileTooLargeError, FilesUnavailableError, HandlerFailedError, HistoryPrunedError, HostedAppBuildError, InUseError, InvalidFileRequestError, InvalidRequestError, InvalidSecretNameError, LayoutVersionError, ListenerNotLoopbackError, LocalEnvironment, LocalEnvironments, LocalSnapshot, MigrationEditedError, MigrationFailedError, MigrationHasher, MigrationMissingError, NotFoundError, Promotion, ReplayCursorStalledError, ReservedMemberError, ReservedNameError, ReservedPayloadFieldError, SecretUnavailableError, SnapshotName, SpendCapReachedError, StateUnreadableError, StepNotFoundError, StorageLimitError, StoreUnreadableError, UnauthenticatedError, Verify };

package/dist/runtime/blob-hashing.layer.d.mts

@@ -0,0 +1,4 @@
+import { BlobHashing } from "../host/hash/blob-hashing.service.mjs";
+import { Layer } from "effect";
+declare const blobHashing: Layer.Layer<BlobHashing>;
+export { blobHashing };

package/dist/runtime/blob-hashing.layer.mjs

@@ -0,0 +1,15 @@
+import { BlobHashing } from "../host/hash/blob-hashing.service.mjs";
+import { Effect, Layer } from "effect";
+import { createHash } from "node:crypto";
+// src/runtime/blob-hashing.layer.ts
+const sha256 = Effect.sync(() => {
+	const hash = createHash("sha256");
+	return {
+		digest: Effect.sync(() => hash.digest("hex")),
+		update: (bytes) => Effect.sync(() => {
+			hash.update(bytes);
+		})
+	};
+});
+const blobHashing = Layer.succeed(BlobHashing, { sha256 });
+export { blobHashing };

package/dist/runtime/hosted-environment.layer.d.mts

@@ -0,0 +1,34 @@
+import { LocalBlobHomes } from "../host/file/local-blob-home.service.mjs";
+import { SqliteDriver } from "../host/sqlite/sqlite-driver.service.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { ActorLocation } from "../serve/engine/actor-location.service.mjs";
+import { Cut } from "../serve/environment/snapshot-operations.sql.mjs";
+import { Context, Effect, FileSystem, Latch, Path, Scope } from "effect";
+/**
+ * What an environment's engine needs from the local engine around it. The context also carries what isn't typed
+ * here: the app's handlers, the job engine their jobs run on, and settings such as the history retention.
+ */
+type EngineContext = Context.Context<FileSystem.FileSystem | Path.Path | SqliteDriver>;
+/** The environment the local engine serves now, on an engine of its own that closes with `scope`. */
+interface HostedEnvironment {
+  /** Open while the environment isn't quiet; its actors' upkeep waits at it. */
+  readonly gate: Latch.Latch;
+  readonly host: ActorHost["Service"];
+  readonly homes: LocalBlobHomes["Service"];
+  readonly location: ActorLocation["Service"];
+  readonly name: string;
+  readonly scope: Scope.Closeable;
+  /** The environment's store, the directory its shards and files are in. */
+  readonly store: string;
+}
+interface EnvironmentOpening {
+  readonly context: EngineContext;
+  readonly name: string;
+  readonly quiet: number;
+  readonly store: string;
+}
+/** Opens one environment's engine, quiet when its record says so, with every service it needs from `context`. */
+declare const openEnvironment: (args_0: EnvironmentOpening) => Effect.Effect<HostedEnvironment, never, never>;
+/** How a snapshot cuts the hosted environment's store: each actor under its command lock, under its files' hold. */
+declare const cutOf: (context: EngineContext) => ({ homes, host, location, store }: HostedEnvironment) => Cut;
+export { type EngineContext, type EnvironmentOpening, type HostedEnvironment, cutOf, openEnvironment };

package/dist/runtime/hosted-environment.layer.mjs

@@ -0,0 +1,40 @@
+import { LocalBlobHomes } from "../host/file/local-blob-home.service.mjs";
+import { SqliteDriver } from "../host/sqlite/sqlite-driver.service.mjs";
+import { UpkeepGate } from "../host/upkeep/execution-authority.pure.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { ActorLocation } from "../serve/engine/actor-location.service.mjs";
+import { cutStore } from "../serve/environment/store-snapshot.sql.mjs";
+import { actorEngine } from "../serve/engine/actor-engine.layer.mjs";
+import { fileHomes } from "./local-actor-engine.layer.mjs";
+import { Context, Effect, Exit, Latch, Layer, Scope } from "effect";
+// src/runtime/hosted-environment.layer.ts
+const quietFlag = 1;
+/** The engine of one environment's store: its host, where its actors are, and its file home. */
+const environmentEngine = (directory) => Layer.merge(actorEngine(directory), ActorLocation.directory(directory)).pipe(Layer.provideMerge(fileHomes(directory)));
+/** Opens one environment's engine, quiet when its record says so, with every service it needs from `context`. */
+const openEnvironment = Effect.fnUntraced(function* openEnvironment({ context, name, quiet, store }) {
+	const scope = yield* Scope.make();
+	const gate = yield* Latch.make(quiet !== quietFlag);
+	const engine = environmentEngine(store).pipe(Layer.provide(Layer.succeed(UpkeepGate, gate)));
+	const built = Layer.buildWithScope(engine, scope).pipe(Effect.provideContext(context));
+	const services = yield* Effect.onError(built, (cause) => Scope.close(scope, Exit.failCause(cause)));
+	return {
+		gate,
+		homes: Context.get(services, LocalBlobHomes),
+		host: Context.get(services, ActorHost),
+		location: Context.get(services, ActorLocation),
+		name,
+		scope,
+		store
+	};
+});
+/** How a snapshot cuts the hosted environment's store: each actor under its command lock, under its files' hold. */
+const cutOf = (context) => ({ homes, host, location, store }) => (into) => Effect.flatMap(homes.get, (home) => cutStore({
+	driver: Context.get(context, SqliteDriver),
+	home,
+	host,
+	into,
+	location,
+	store
+})).pipe(Effect.provideContext(context));
+export { cutOf, openEnvironment };

package/dist/runtime/http-server.layer.d.mts

@@ -0,0 +1,9 @@
+import { FileSystem, Layer, Path } from "effect";
+import { HttpServer, HttpServerError } from "effect/http";
+type PlatformHttpServer = Layer.Layer<FileSystem.FileSystem | HttpServer.HttpServer | Path.Path, HttpServerError.ServeError>;
+interface Listener {
+  readonly hostname: string;
+  readonly port: number;
+}
+export declare const httpServer: ({ hostname, port }: Listener) => PlatformHttpServer;
+export {};

package/dist/runtime/http-server.layer.mjs

@@ -0,0 +1,15 @@
+import { Effect, Layer } from "effect";
+import { createServer } from "node:http";
+import { layer } from "@effect/platform-node/NodeHttpServer";
+// src/runtime/http-server.layer.ts
+const httpServer = ({ hostname, port }) => {
+	if ("Bun" in globalThis) return Layer.unwrap(Effect.map(Effect.promise(() => import("@effect/platform-bun/BunHttpServer")), (BunHttpServer) => BunHttpServer.layer({
+		hostname,
+		port
+	})));
+	return layer(createServer, {
+		host: hostname,
+		port
+	});
+};
+export { httpServer };

package/dist/runtime/local-actor-engine.layer.d.mts

@@ -0,0 +1,10 @@
+import { ActorRegistry } from "../contract/actor/actor-registry.service.mjs";
+import { ActorJournal } from "../contract/history/actor-journal.service.mjs";
+import { LocalBlobHomes } from "../host/file/local-blob-home.service.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { localFileClients } from "./local-file-clients.layer.mjs";
+import { FileSystem, Layer, Path } from "effect";
+declare const fileHomes: (directory: string) => Layer.Layer<LocalBlobHomes, never, FileSystem.FileSystem | Path.Path>;
+type LocalActorEngineServices = ActorHost | ActorJournal | ActorRegistry | Layer.Success<typeof localFileClients>;
+declare const localActorEngine: (directory: string) => Layer.Layer<LocalActorEngineServices, never, FileSystem.FileSystem | Path.Path>;
+export { type LocalActorEngineServices, fileHomes, localActorEngine };

package/dist/runtime/local-actor-engine.layer.mjs

@@ -0,0 +1,14 @@
+import { LocalBlobHomes } from "../host/file/local-blob-home.service.mjs";
+import { SqliteDriver } from "../host/sqlite/sqlite-driver.service.mjs";
+import { actorEngine, hostJournal } from "../serve/engine/actor-engine.layer.mjs";
+import { blobHashing } from "./blob-hashing.layer.mjs";
+import { localFileClients } from "./local-file-clients.layer.mjs";
+import { Effect, Layer, Path } from "effect";
+import { SecureRandom } from "effect/crypto";
+// src/runtime/local-actor-engine.layer.ts
+const fileHomes = (directory) => Layer.unwrap(Effect.map(Path.Path, (path) => LocalBlobHomes.layer(path.join(directory, "files-home")))).pipe(Layer.provide(blobHashing), Layer.provide(SecureRandom.layerWebCrypto), Layer.provide(SqliteDriver.layerNode));
+const localActorEngine = (directory) => {
+	const engine = hostJournal.pipe(Layer.provideMerge(actorEngine(directory)), Layer.provide(fileHomes(directory)));
+	return localFileClients.pipe(Layer.provideMerge(engine));
+};
+export { fileHomes, localActorEngine };

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

@@ -0,0 +1,15 @@
+import { hostJournal, providedHandlers } from "../serve/engine/actor-engine.layer.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { LocalEnvironments } from "../serve/environment/local-environments.service.mjs";
+import { LocalOptions, offlineEnvironments } from "./local-environments.layer.mjs";
+import { localFileClients } from "./local-file-clients.layer.mjs";
+import { ComputerNeeds } from "./local-job-runtime.layer.mjs";
+import { Layer } from "effect";
+/**
+ * The local engine `Akter.local` runs: the data directory's environments behind one switching host, with the
+ * journal, the file clients, the registry of the handlers it is given, and, with `AKTER_LOCAL_COMPUTERS` on, the
+ * computers of the store it serves, which the app's jobs reach through the same `JobComputers` that `Akter.jobs` gives
+ * them and its `<Actor>/computer/*` RPCs reach directly.
+ */
+declare const localEngine: (options: LocalOptions) => Layer.Layer<ActorHost | LocalEnvironments | Layer.Success<typeof hostJournal> | Layer.Success<typeof localFileClients> | Layer.Success<typeof providedHandlers>, never, ComputerNeeds>;
+export { localEngine, offlineEnvironments };

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

@@ -0,0 +1,14 @@
+import { JobComputers } from "../host/computer/job-computers.service.mjs";
+import { hostJournal, providedHandlers } from "../serve/engine/actor-engine.layer.mjs";
+import { localEnvironments, offlineEnvironments } from "./local-environments.layer.mjs";
+import { localFileClients } from "./local-file-clients.layer.mjs";
+import { Layer } from "effect";
+// src/runtime/local-engine.layer.ts
+/**
+* The local engine `Akter.local` runs: the data directory's environments behind one switching host, with the
+* journal, the file clients, the registry of the handlers it is given, and, with `AKTER_LOCAL_COMPUTERS` on, the
+* computers of the store it serves, which the app's jobs reach through the same `JobComputers` that `Akter.jobs` gives
+* them and its `<Actor>/computer/*` RPCs reach directly.
+*/
+const localEngine = (options) => Layer.mergeAll(localFileClients, hostJournal).pipe(Layer.provideMerge(localEnvironments(options)), Layer.provideMerge(providedHandlers), Layer.provideMerge(JobComputers.layer));
+export { localEngine, offlineEnvironments };

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

@@ -0,0 +1,24 @@
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { LocalEnvironments } from "../serve/environment/local-environments.service.mjs";
+import { BinderNeeds } from "./local-job-runtime.layer.mjs";
+import { FileSystem, Layer, Path } from "effect";
+interface LocalOptions {
+  /** The data directory, `.akter` for `akter dev`. */
+  readonly directory: string;
+  /**
+   * Serve this environment of the data directory, such as a branch to call before promoting it, instead of the one
+   * promoted to serve. It stays quiet until it is promoted.
+   */
+  readonly environment?: string | undefined;
+}
+/**
+ * The local engine on a data directory's environments: it serves one of them at a time through one actor host, and
+ * switches to another when a promote makes it serve. `LocalEnvironments` snapshots, branches and promotes them.
+ */
+declare const localEnvironments: (options: LocalOptions) => Layer.Layer<ActorHost | LocalEnvironments, never, BinderNeeds>;
+/**
+ * A data directory's environments without an engine, as the CLI reads them: what it changes, the `akter dev` serving
+ * the directory applies on its next look, and a snapshot is waited for while that engine takes it.
+ */
+declare const offlineEnvironments: (directory: string) => Layer.Layer<LocalEnvironments, never, FileSystem.FileSystem | Path.Path>;
+export { type LocalOptions, localEnvironments, offlineEnvironments };

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

@@ -0,0 +1,159 @@
+import { SqliteDriver } from "../host/sqlite/sqlite-driver.service.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { environmentRow, servingRow } from "../serve/environment/environment-records.sql.mjs";
+import { LocalEnvironments } from "../serve/environment/local-environments.service.mjs";
+import { takePending } from "../serve/environment/snapshot-operations.sql.mjs";
+import { cutOf, openEnvironment } from "./hosted-environment.layer.mjs";
+import { computersBinder } from "./local-job-runtime.layer.mjs";
+import { Context, Duration, Effect, Exit, Latch, Layer, Option, Ref, Schedule, Scope, Semaphore, Stream } from "effect";
+// src/runtime/local-environments.layer.ts
+/** How often the engine reads the record, for what `akter dev environments` and `snapshots` changed in another process. */
+const watchEvery = "1 second";
+const settleWithin = Duration.seconds(30);
+const quietFlag = 1;
+const oneAtATime = 1;
+/**
+* An actor host that answers each call with whichever host `current` gives at that moment, so the local engine can
+* switch the environment it serves, as a promote does, while the server and its clients stay as they are.
+*/
+const switchingHost = (current) => ({
+	command: (call) => Effect.flatMap(current, (host) => host.command(call)),
+	coveredSince: (request) => Effect.flatMap(current, (host) => host.coveredSince(request)),
+	create: (call) => Effect.flatMap(current, (host) => host.create(call)),
+	currentFiles: (address) => Effect.flatMap(current, (host) => host.currentFiles(address)),
+	drain: Effect.flatMap(current, (host) => host.drain),
+	erase: (address) => Effect.flatMap(current, (host) => Option.match(Option.fromNullishOr(host.erase), {
+		onNone: () => Effect.die("the local engine has no actor erasure"),
+		onSome: (erase) => erase(address)
+	})),
+	files: (address) => Effect.flatMap(current, (host) => host.files(address)),
+	fork: (call) => Effect.flatMap(current, (host) => host.fork(call)),
+	history: (request) => Effect.flatMap(current, (host) => host.history(request)),
+	prepareFiles: (address) => Effect.flatMap(current, (host) => host.prepareFiles(address)),
+	query: (call) => Effect.flatMap(current, (host) => host.query(call)),
+	state: (address) => Stream.unwrap(Effect.map(current, (host) => host.state(address))),
+	step: (request) => Effect.flatMap(current, (host) => host.step(request)),
+	steps: (request) => Effect.flatMap(current, (host) => host.steps(request)),
+	subscribe: (call) => Stream.unwrap(Effect.map(current, (host) => host.subscribe(call))),
+	warm: (address) => Effect.flatMap(current, (host) => host.warm(address))
+});
+const hostingOf = ({ context, store }, row) => ({
+	context,
+	name: row.name,
+	quiet: row.quiet,
+	store: store.path.resolve(store.directory, row.directory)
+});
+const switchTo = Effect.fnUntraced(function* switchTo(switcher, row) {
+	const before = yield* Ref.get(switcher.current);
+	yield* switcher.ready.close;
+	yield* Scope.close(before.scope, Exit.void);
+	const next = yield* openEnvironment(hostingOf(switcher, row));
+	yield* switcher.bindComputers(next.store);
+	yield* Ref.set(switcher.current, next);
+	yield* switcher.ready.open;
+});
+const quietAs = (gate, row) => {
+	if (row.quiet === quietFlag) return gate.close;
+	return gate.open;
+};
+/** The environment the record says this engine serves: the pinned one, or the one promoted to serve, while Ready. */
+const servedRow = Effect.fnUntraced(function* servedRow({ pinned, store }) {
+	const serving = yield* servingRow(store);
+	const wanted = Option.getOrElse(pinned, () => serving.environment);
+	const found = yield* environmentRow({
+		name: wanted,
+		sql: store.sql
+	});
+	return Option.filter(found, (row) => row.status === "Ready");
+});
+/**
+* Applies the record: serves the environment it names (the pinned one, or the one promoted to serve), holds its
+* actors' upkeep while it is quiet and runs it once it isn't, and takes its pending snapshots.
+*/
+const applied = Effect.fnUntraced(function* applied(switcher) {
+	const { store } = switcher;
+	const row = yield* servedRow(switcher);
+	const hosted = yield* Ref.get(switcher.current);
+	if (Option.isSome(row) && row.value.name !== hosted.name) yield* switchTo(switcher, row.value);
+	const current = yield* Ref.get(switcher.current);
+	yield* Effect.forEach(Option.toArray(row), (now) => quietAs(current.gate, now));
+	yield* takePending({
+		cut: cutOf(switcher.context)(current),
+		store
+	})(current.name);
+});
+const firstHosted = Effect.fnUntraced(function* firstHosted({ context, store }, pinned) {
+	const ready = yield* servedRow({
+		pinned,
+		store
+	});
+	const unknown = Effect.die(`akter dev has no Ready environment ${Option.getOrElse(pinned, () => "")} to serve`);
+	const row = yield* Option.match(ready, {
+		onNone: () => unknown,
+		onSome: Effect.succeed
+	});
+	return yield* openEnvironment(hostingOf({
+		context,
+		store
+	}, row));
+});
+const openRecord = (directory, hosting) => Effect.orDie(SqliteDriver.use((driver) => LocalEnvironments.openStore({
+	directory,
+	hosting,
+	open: driver.open
+})));
+const startSwitcher = Effect.fnUntraced(function* startSwitcher({ directory, environment }) {
+	const context = yield* Effect.context();
+	const bindComputers = yield* computersBinder();
+	const store = yield* openRecord(directory, {
+		apply: Effect.void,
+		settleWithin: Duration.zero
+	});
+	const pinned = Option.fromUndefinedOr(environment);
+	const first = yield* Effect.orDie(firstHosted({
+		context,
+		store
+	}, pinned));
+	yield* bindComputers(first.store);
+	const current = yield* Ref.make(first);
+	const ready = yield* Latch.make(true);
+	yield* Effect.addFinalizer(() => Effect.flatMap(Ref.get(current), (hosted) => Scope.close(hosted.scope, Exit.void)));
+	return {
+		bindComputers,
+		context,
+		current,
+		pinned,
+		ready,
+		store
+	};
+});
+const applying = (switcher, semaphore) => semaphore.withPermits(oneAtATime)(applied(switcher)).pipe(Effect.catchCause((cause) => Effect.logWarning("akter dev could not apply its environments", cause)));
+/**
+* The local engine on a data directory's environments: it serves one of them at a time through one actor host, and
+* switches to another when a promote makes it serve. `LocalEnvironments` snapshots, branches and promotes them.
+*/
+const localEnvironments = (options) => Layer.effectContext(Effect.gen(function* makeLocalEnvironments() {
+	const switcher = yield* startSwitcher(options);
+	const semaphore = yield* Semaphore.make(oneAtATime);
+	const apply = applying(switcher, semaphore);
+	const served = Effect.andThen(switcher.ready.await, Ref.get(switcher.current));
+	yield* Effect.forkScoped(Effect.repeat(apply, Schedule.spaced(watchEvery)));
+	const environments = LocalEnvironments.on({
+		...switcher.store,
+		hosting: {
+			apply,
+			settleWithin: Duration.zero
+		}
+	});
+	const host = switchingHost(Effect.map(served, (hosted) => hosted.host));
+	return Context.make(ActorHost, host).pipe(Context.add(LocalEnvironments, environments));
+})).pipe(Layer.provide(SqliteDriver.layerNode));
+/**
+* A data directory's environments without an engine, as the CLI reads them: what it changes, the `akter dev` serving
+* the directory applies on its next look, and a snapshot is waited for while that engine takes it.
+*/
+const offlineEnvironments = (directory) => Layer.effect(LocalEnvironments, Effect.map(openRecord(directory, {
+	apply: Effect.void,
+	settleWithin
+}), LocalEnvironments.on)).pipe(Layer.provide(SqliteDriver.layerNode));
+export { localEnvironments, offlineEnvironments };

package/dist/runtime/local-file-clients.layer.d.mts

@@ -0,0 +1,13 @@
+import { ActorFileClients } from "../contract/file/file-client.adapter.mjs";
+import { FileAddress, FileClient } from "../contract/file/file-client.contract.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { Layer } from "effect";
+interface FileBinding {
+  readonly address: FileAddress;
+  readonly host: ActorHost["Service"];
+}
+declare const clientWith: (binding: FileBinding) => FileClient;
+/** The file client of one actor on this host, outside its commands and queries. */
+declare const hostFileClient: typeof clientWith;
+declare const localFileClients: Layer.Layer<ActorFileClients, never, ActorHost>;
+export { hostFileClient, localFileClients };