@akterjs/effect 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,68 @@
+import { HostedError } from "../../contract/hosted/hosted-error.contract.mjs";
+import "../../contract/actor/actor.contract.mjs";
+import { OpenedActor } from "../actor/actor-database.service.mjs";
+import { CommandContext } from "./command-context.adapter.mjs";
+import { Context, Duration, Effect, Layer } from "effect";
+import { SqlError } from "effect/sql";
+interface CommandRequest {
+  readonly commandId: string;
+  readonly key: string;
+  readonly member: string;
+  readonly payload: string;
+  readonly principal: string;
+}
+interface CreationRequest {
+  readonly commandId: string;
+  readonly key: string;
+  readonly mode: "create" | "ensure";
+  readonly payload: string;
+  readonly principal: string;
+}
+interface ResultRequest {
+  readonly commandId: string;
+  readonly job: string;
+  readonly key: string;
+  readonly payload: string;
+  readonly principal: string;
+}
+interface Resulting {
+  readonly opened: OpenedActor;
+  readonly request: ResultRequest;
+}
+interface Running {
+  readonly opened: OpenedActor;
+  readonly request: CommandRequest;
+}
+interface Creating {
+  readonly opened: OpenedActor;
+  readonly request: CreationRequest;
+}
+interface Pruning {
+  readonly before: number;
+  readonly opened: OpenedActor;
+}
+type Outcome = Effect.Effect<string, HostedError | SqlError.SqlError>;
+declare const CommandRunner_base: Context.ServiceClass<CommandRunner, "@akterjs/effect/host/command/command-runner.service/CommandRunner", {
+  readonly create: (creating: Creating) => Outcome;
+  readonly prune: (pruning: Pruning) => Effect.Effect<void, SqlError.SqlError>;
+  readonly replay: (running: Running) => Outcome;
+  readonly result: (resulting: Resulting) => Outcome;
+  readonly run: (running: Running) => Outcome;
+  readonly runOwn: (running: Running) => Outcome;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly create: (creating: Creating) => Outcome;
+    readonly prune: (pruning: Pruning) => Effect.Effect<void, SqlError.SqlError>;
+    readonly replay: (running: Running) => Outcome;
+    readonly result: (resulting: Resulting) => Outcome;
+    readonly run: (running: Running) => Outcome;
+    readonly runOwn: (running: Running) => Outcome;
+  }, never, CommandContext>;
+};
+export declare class CommandRunner extends CommandRunner_base {
+  static readonly historyRetention: Context.Reference<Duration.Duration>;
+  /** Whether a failed statement's message reaches the caller or only the host's log. */
+  static readonly statementDetail: Context.Reference<"logged" | "shown">;
+  static readonly layer: Layer.Layer<CommandRunner, never, never>;
+}
+export type { CommandRequest, CreationRequest, Running };

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

@@ -0,0 +1,215 @@
+import { HandlerSql } from "../query/query-policy.pure.mjs";
+import { CommandContext } from "./command-context.adapter.mjs";
+import { checkCommandId } from "./command-id-age.pure.mjs";
+import { isResultCommandId, isTimerCommandId, jobIdOfResult, jobOfResult, refuseReserved, refuseReuse, resultMember, reuseDefect, sameCommand } from "./command-id-reuse.pure.mjs";
+import { CommandBatchJournal } from "./batch/command-batch.sql.mjs";
+import { currentState, pruneJournal, recordCommand, recordedCommand, settle } from "./command-journal.sql.mjs";
+import { journalFailure, replyOf } from "./command-reply.pure.mjs";
+import { Clock, Context, Duration, Effect, HashMap, Layer, Option } from "effect";
+// src/host/command/command-runner.service.ts
+const creationModes = HashMap.make(["akter.create", "create"], ["akter.ensure", "ensure"]);
+const internal = {
+	admit: () => Effect.void,
+	reused: reuseDefect,
+	screen: () => Effect.void
+};
+const HistoryRetention = Context.Reference("@akterjs/effect/host/command/command-runner.service/HistoryRetention", { defaultValue: () => Duration.infinity });
+const admitting = (retention) => ({ opened, request }) => {
+	if (!Duration.isFinite(retention)) return Effect.void;
+	return Effect.flatMap(Clock.currentTimeMillis, (now) => checkCommandId({
+		actor: opened.actor.name,
+		commandId: request.commandId,
+		keptSince: now - Duration.toMillis(retention),
+		now
+	}));
+};
+const fromClient = (retention) => ({
+	admit: admitting(retention),
+	reused: refuseReuse,
+	screen: ({ opened, request }) => refuseReserved({
+		actor: opened.actor.name,
+		commandId: request.commandId,
+		principal: request.principal
+	})
+});
+/** Runs the handler and saves its outcome in one savepoint; the outcome's writes go through the batch's writer. */
+const settled = Effect.fnUntraced(function* settled({ at, handled, principal, sql }) {
+	const writer = yield* CommandBatchJournal.writer(sql);
+	const saving = Effect.flatMap(handled, (outcome) => Effect.tap(settle({
+		at,
+		outcome,
+		principal,
+		sql: writer
+	}), () => Option.match(outcome.state, {
+		onNone: () => Effect.void,
+		onSome: CommandBatchJournal.saved
+	})));
+	return yield* sql.withTransaction(saving).pipe(Effect.catchTags({
+		ActorAlreadyExistsError: journalFailure,
+		CommandRejectedError: (rejected) => Effect.succeed(rejected.exit),
+		HandlerFailedError: journalFailure
+	}));
+});
+/** Writes the command's journal row; inside an engine batch, at the seq the batch journal gives it. */
+const journal = Effect.fnUntraced(function* journal(row, sql) {
+	const { command, commandId, exit, principal } = row;
+	const seq = yield* CommandBatchJournal.record(commandId, {
+		command,
+		exit,
+		principal
+	});
+	yield* recordCommand({
+		row,
+		seq,
+		sql: yield* CommandBatchJournal.writer(sql)
+	});
+});
+const execute = Effect.fnUntraced(function* execute({ context, invoke, opened, request }) {
+	const { sql } = opened;
+	const at = yield* Clock.currentTimeMillis;
+	const state = yield* CommandBatchJournal.state(sql, currentState(sql));
+	const tracked = yield* context.track({
+		files: opened.files(sql),
+		key: request.key,
+		sql
+	});
+	const handled = Effect.provideService(invoke({
+		...request,
+		state
+	}, tracked.environment), HandlerSql, true);
+	const journaled = yield* settled({
+		at,
+		handled,
+		principal: request.principal,
+		sql
+	});
+	const recorded = yield* tracked.recorded;
+	const { commandId, member: command, payload, principal } = request;
+	yield* journal({
+		...recorded,
+		at,
+		command,
+		commandId,
+		exit: journaled,
+		payload,
+		principal
+	}, sql);
+	return journaled;
+});
+const replayed = (gate, { opened, request }, recorded) => {
+	const reuse = {
+		actor: opened.actor.name,
+		commandId: request.commandId,
+		member: request.member,
+		principal: request.principal,
+		recordedMember: recorded.command,
+		recordedPrincipal: recorded.principal
+	};
+	if (!sameCommand(reuse)) return gate.reused(reuse);
+	return Effect.succeed(recorded.exit);
+};
+const onceWith = (context) => Effect.fnUntraced(function* once(running, invoke, gate) {
+	const { opened, request } = running;
+	yield* gate.screen(running);
+	const journaled = yield* opened.sql.withTransaction(Effect.gen(function* runOnce() {
+		const recorded = yield* CommandBatchJournal.recorded(opened.sql, request.commandId, recordedCommand({
+			commandId: request.commandId,
+			sql: opened.sql
+		}));
+		if (Option.isSome(recorded)) return yield* replayed(gate, running, recorded.value);
+		yield* gate.admit(running);
+		return yield* execute({
+			context,
+			invoke,
+			opened,
+			request
+		}).pipe(Effect.annotateLogs({
+			actor: opened.actor.name,
+			commandId: request.commandId
+		}));
+	}));
+	return yield* replyOf(journaled);
+});
+const replayWith = ({ create, result, run, runOwn }) => (running) => {
+	const { opened, request } = running;
+	if (isTimerCommandId(request.commandId)) return runOwn(running);
+	if (isResultCommandId(request.commandId)) return result({
+		opened,
+		request: {
+			...request,
+			job: jobOfResult(request.member)
+		}
+	});
+	return Option.match(HashMap.get(creationModes, request.member), {
+		onNone: () => run(running),
+		onSome: (mode) => create({
+			opened,
+			request: {
+				...request,
+				mode
+			}
+		})
+	});
+};
+const prune = ({ before, opened }) => Effect.andThen(pruneJournal({
+	before,
+	sql: opened.sql
+}), CommandBatchJournal.forget);
+var CommandRunner = class extends Context.Service()("@akterjs/effect/host/command/command-runner.service/CommandRunner", { make: Effect.gen(function* makeCommandRunner() {
+	const context = yield* CommandContext;
+	const retention = yield* HistoryRetention;
+	const once = onceWith(context);
+	const client = fromClient(retention);
+	const run = Effect.fn("CommandRunner.run")(function* run(running) {
+		return yield* once(running, running.opened.actor.runCommand, client);
+	});
+	const create = Effect.fn("CommandRunner.create")(function* create({ opened, request }) {
+		const member = `akter.${request.mode}`;
+		return yield* once({
+			opened,
+			request: {
+				...request,
+				member
+			}
+		}, (hosted, environment) => opened.actor.runCreate({
+			...hosted,
+			member: request.mode
+		}, environment), client);
+	});
+	const result = Effect.fn("CommandRunner.result")(function* result({ opened, request: { job, ...rest } }) {
+		const member = resultMember(job);
+		return yield* once({
+			opened,
+			request: {
+				...rest,
+				member
+			}
+		}, (hosted, environment) => opened.actor.runResult({
+			...hosted,
+			jobId: jobIdOfResult(rest.commandId),
+			member: job
+		}, environment), internal);
+	});
+	const runOwn = Effect.fn("CommandRunner.runOwn")(function* runOwn(running) {
+		return yield* once(running, running.opened.actor.runCommand, internal);
+	});
+	return {
+		create,
+		prune,
+		replay: replayWith({
+			create,
+			result,
+			run,
+			runOwn
+		}),
+		result,
+		run,
+		runOwn
+	};
+}) }) {
+	static historyRetention = HistoryRetention;
+	/** Whether a failed statement's message reaches the caller or only the host's log. */
+	static statementDetail = CommandContext.statementDetail;
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide(CommandContext.layer));
+};
+export { CommandRunner };

package/dist/host/command/files/command-file-inputs.sql.d.mts

@@ -0,0 +1,51 @@
+import { FileStorage } from "../../../contract/file/actor-files.contract.mjs";
+import { Effect, Ref, Schema } from "effect";
+import { SqlClient, SqlError } from "effect/sql";
+declare const FileInput: Schema.Struct<{
+  readonly receipt: Schema.String;
+  readonly row: Schema.Option<Schema.Struct<{
+    readonly actor: Schema.String;
+    readonly blob: Schema.String;
+    readonly bytes: Schema.Int;
+    readonly claim: Schema.String;
+    readonly expiresAt: Schema.Int;
+    readonly grant: Schema.String;
+    readonly receipt: Schema.String;
+    readonly sha256: Schema.String;
+    readonly state: Schema.Literals<readonly ["uploading", "prepared", "consumed", "canceled"]>;
+  }>>;
+}>;
+declare const FileInputs: Schema.fromJsonString<Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+  readonly receipt: Schema.String;
+  readonly row: Schema.Option<Schema.Struct<{
+    readonly actor: Schema.String;
+    readonly blob: Schema.String;
+    readonly bytes: Schema.Int;
+    readonly claim: Schema.String;
+    readonly expiresAt: Schema.Int;
+    readonly grant: Schema.String;
+    readonly receipt: Schema.String;
+    readonly sha256: Schema.String;
+    readonly state: Schema.Literals<readonly ["uploading", "prepared", "consumed", "canceled"]>;
+  }>>;
+}>>>>;
+type FileInputValue = typeof FileInput.Type;
+interface Capturing {
+  readonly files: FileStorage;
+  readonly sql: SqlClient.SqlClient;
+  readonly used: Ref.Ref<readonly FileInputValue[]>;
+}
+interface Replaying {
+  readonly files: FileStorage;
+  readonly inputs: readonly FileInputValue[];
+  readonly sql: SqlClient.SqlClient;
+}
+interface Retaining {
+  readonly commandId: string;
+  readonly recorded: string;
+  readonly sql: SqlClient.SqlClient;
+}
+declare const captureFileInputs: ({ files, sql, used }: Capturing) => FileStorage;
+declare const replayFileInputs: ({ files, sql, inputs }: Replaying) => Effect.Effect<FileStorage>;
+declare const retainFileInputs: ({ sql, commandId, recorded }: Retaining) => Effect.Effect<void, SqlError.SqlError>;
+export { type FileInputValue, FileInputs, captureFileInputs, replayFileInputs, retainFileInputs };

package/dist/host/command/files/command-file-inputs.sql.mjs

@@ -0,0 +1,59 @@
+import { BlobTransferError } from "../../../contract/file/blob-transfer.errors.mjs";
+import { Array, Effect, Option, Ref, Schema } from "effect";
+// src/host/command/files/command-file-inputs.sql.ts
+const ReceiptInput = Schema.Struct({
+	actor: Schema.String,
+	blob: Schema.String,
+	bytes: Schema.Int,
+	claim: Schema.String,
+	expiresAt: Schema.Int,
+	grant: Schema.String,
+	receipt: Schema.String,
+	sha256: Schema.String,
+	state: Schema.Literals([
+		"uploading",
+		"prepared",
+		"consumed",
+		"canceled"
+	])
+});
+const FileInput = Schema.Struct({
+	receipt: Schema.String,
+	row: Schema.Option(ReceiptInput)
+});
+const FileInputs = Schema.fromJsonString(Schema.toCodecJson(Schema.Array(FileInput)));
+const consumedInput = 1;
+const fileInput = (sql, receipt) => Effect.map(sql`SELECT actor, blob, bytes, claim, expires_at AS expiresAt, grant, receipt, sha256, state FROM akter_blob_receipts WHERE receipt = ${receipt}`, (rows) => ({
+	receipt,
+	row: Array.head(rows)
+}));
+const captureFileInputs = ({ files, sql, used }) => ({
+	...files,
+	attach: (attaching) => Effect.gen(function* captureAttachment() {
+		yield* files.available;
+		const input = yield* fileInput(sql, attaching.receipt);
+		yield* Ref.update(used, (inputs) => Array.append(inputs, input));
+		return yield* files.attach(attaching);
+	})
+});
+const restoreInput = (sql, input) => Option.match(input.row, {
+	onNone: () => Effect.asVoid(sql`DELETE FROM akter_blob_receipts WHERE receipt = ${input.receipt}`),
+	onSome: (row) => Effect.asVoid(sql`INSERT INTO akter_blob_receipts (receipt, actor, blob, claim, expires_at, bytes, sha256, grant, state) VALUES (${row.receipt}, ${row.actor}, ${row.blob}, ${row.claim}, ${row.expiresAt}, ${row.bytes}, ${row.sha256}, ${row.grant}, ${row.state}) ON CONFLICT (receipt) DO UPDATE SET actor = excluded.actor, blob = excluded.blob, claim = excluded.claim, expires_at = excluded.expires_at, bytes = excluded.bytes, sha256 = excluded.sha256, grant = excluded.grant, state = excluded.state`)
+});
+const replayFileInputs = ({ files, sql, inputs }) => Effect.map(Ref.make(inputs), (left) => ({
+	...files,
+	attach: (attaching) => Effect.gen(function* replayAttachment() {
+		const input = yield* Ref.modify(left, (remaining) => [Array.head(remaining), Array.drop(remaining, consumedInput)]);
+		if (Option.isNone(input) || input.value.receipt !== attaching.receipt) return yield* BlobTransferError.make({
+			blob: "",
+			message: "the replay did not record this upload receipt"
+		});
+		yield* restoreInput(sql, input.value);
+		return yield* files.attach(attaching);
+	})
+}));
+const retainFileInputs = ({ sql, commandId, recorded }) => Effect.flatMap(Effect.orDie(Schema.decodeEffect(FileInputs)(recorded)), (inputs) => Effect.forEach(inputs, (input) => Option.match(input.row, {
+	onNone: () => Effect.void,
+	onSome: (row) => Effect.andThen(sql`INSERT INTO akter_blob_history (command_id, claim, actor, blob) VALUES (${commandId}, ${row.claim}, ${row.actor}, ${row.blob}) ON CONFLICT DO NOTHING`, Effect.asVoid(sql`DELETE FROM akter_blob_releases WHERE claim = ${row.claim}`))
+}), { discard: true }));
+export { FileInputs, captureFileInputs, replayFileInputs, retainFileInputs };

package/dist/host/command/history-pruned.errors.d.mts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+declare const HistoryPrunedError_base: Schema.Class<HistoryPrunedError, Schema.TaggedStruct<"HistoryPrunedError", {
+  readonly actor: Schema.String;
+  readonly coveredSince: Schema.Int;
+  readonly key: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class HistoryPrunedError extends HistoryPrunedError_base {}
+export {};

package/dist/host/command/history-pruned.errors.mjs

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+// src/host/command/history-pruned.errors.ts
+var HistoryPrunedError = class extends Schema.TaggedError()("HistoryPrunedError", {
+	actor: Schema.String,
+	coveredSince: Schema.Int,
+	key: Schema.String
+}) {};
+export { HistoryPrunedError };

package/dist/host/command/replay/replay-cursor-stalled.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const ReplayCursorStalledError_base: Schema.Class<ReplayCursorStalledError, Schema.TaggedStruct<"ReplayCursorStalledError", {
+  readonly after: Schema.Int;
+  readonly cursor: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class ReplayCursorStalledError extends ReplayCursorStalledError_base {}
+export {};

package/dist/host/command/replay/replay-cursor-stalled.errors.mjs

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+// src/host/command/replay/replay-cursor-stalled.errors.ts
+var ReplayCursorStalledError = class extends Schema.TaggedError()("ReplayCursorStalledError", {
+	after: Schema.Int,
+	cursor: Schema.Int
+}) {};
+export { ReplayCursorStalledError };

package/dist/host/command/replay/replay-cursor.pure.d.mts

@@ -0,0 +1,7 @@
+import { ReplayCursorStalledError } from "./replay-cursor-stalled.errors.mjs";
+import { Option } from "effect";
+declare const stalledCursor: {
+  (after: number): (cursor: number) => Option.Option<ReplayCursorStalledError>;
+  (cursor: number, after: number): Option.Option<ReplayCursorStalledError>;
+};
+export { stalledCursor };

package/dist/host/command/replay/replay-cursor.pure.mjs

@@ -0,0 +1,12 @@
+import { ReplayCursorStalledError } from "./replay-cursor-stalled.errors.mjs";
+import { Option } from "effect";
+import { dual } from "effect/Function";
+// src/host/command/replay/replay-cursor.pure.ts
+const stalledCursor = dual(2, (cursor, after) => {
+	if (cursor > after) return Option.none();
+	return Option.some(ReplayCursorStalledError.make({
+		after,
+		cursor
+	}));
+});
+export { stalledCursor };

package/dist/host/computer/computer-steps.sql.d.mts

@@ -0,0 +1,14 @@
+import { ComputerStep, StepPage } from "../../contract/computer/step/computer-step.schema.mjs";
+import { Effect, Option } from "effect";
+import { SqlClient, SqlError } from "effect/sql";
+type Sql<Value> = Effect.Effect<Value, SqlError.SqlError>;
+/** The actor's steps, newest first, without their output. */
+declare const stepsPage: ({ limit, sql }: StepPage & {
+  readonly sql: SqlClient.SqlClient;
+}) => Sql<readonly ComputerStep[]>;
+/** One step by its key, with its output when it ran. */
+declare const stepByKey: ({ sql, step }: {
+  readonly sql: SqlClient.SqlClient;
+  readonly step: string;
+}) => Sql<Option.Option<ComputerStep>>;
+export { stepByKey, stepsPage };

package/dist/host/computer/computer-steps.sql.mjs

@@ -0,0 +1,76 @@
+import { ExecRan } from "../../contract/computer/computer.schema.mjs";
+import { StepEnd, StepStart, largestPage } from "../../contract/computer/step/computer-step.schema.mjs";
+import { StoredExit } from "../../contract/job/job-signal.schema.mjs";
+import { Array, Cause, Effect, Exit, Option, Record, Schema, Struct } from "effect";
+// src/host/computer/computer-steps.sql.ts
+/**
+* A durable step journals two activities in its job (`computer-step.contract.ts`): `step-start/<name>`, then
+* `step/<name>`. Each is stored as `activity/<activity>/<attempt>`, and a step's name holds no slash.
+*/
+const startPrefix = "activity/step-start/";
+const nameAt = 21;
+/** Every journaled step start with its name, its latest end, and whether its job has a result, filtered by `where`. */
+const stepRows = (where) => `WITH starts AS (SELECT rowid AS seq, execution_id AS job, substr(entry, ${String(nameAt)}, instr(substr(entry, ${String(nameAt)}), '/') - 1) AS name, value AS start FROM akter_workflow WHERE substr(entry, 1, ${String(20)}) = '${startPrefix}') SELECT job, name, start, (SELECT e.value FROM akter_workflow e WHERE e.execution_id = starts.job AND substr(e.entry, 1, length('activity/step/' || starts.name || '/')) = 'activity/step/' || starts.name || '/' ORDER BY e.rowid DESC LIMIT 1) AS "end", EXISTS (SELECT 1 FROM akter_workflow r WHERE r.execution_id = starts.job AND r.entry = 'result') AS finished FROM starts WHERE ${where} ORDER BY seq DESC LIMIT ?`;
+const decodeExit = Schema.decodeUnknownOption(StoredExit);
+const decodeStart = Schema.decodeUnknownOption(Schema.toCodecJson(StepStart));
+const decodeEnd = Schema.decodeUnknownOption(Schema.toCodecJson(StepEnd));
+const isRan = Schema.is(ExecRan);
+const encodeFailure = Schema.encodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+const successOf = (stored) => Option.flatMap(decodeExit(stored), Exit.getSuccess);
+/** A failure as the error the step journaled, as JSON, such as `{"_tag":"ComputerLostError",…}`; `defect` when it died. */
+const failureOf = (cause) => Option.getOrElse(Option.flatMap(Cause.findErrorOption(cause), encodeFailure), () => "defect");
+/** A step with no journaled end: `running` while its job runs, `unknown` once the job finished without settling it. */
+const unsettled = ["running", "unknown"];
+const endedWith = (end) => {
+	if (!isRan(end.outcome)) return {
+		endedAt: end.endedAt,
+		state: "unknown"
+	};
+	const { exitCode, stderr, stdout, truncated } = end.outcome;
+	return {
+		...Record.getSomes({ exitCode: Option.fromUndefinedOr(exitCode) }),
+		endedAt: end.endedAt,
+		state: "ran",
+		stderr,
+		stdout,
+		truncated
+	};
+};
+/** Where a step is: its journaled end, or `running` until its job finishes without one, which leaves it `unknown`. */
+const settledOf = (row) => {
+	const stored = Option.flatMap(Option.fromNullishOr(row.end), decodeExit);
+	return Option.match(stored, {
+		onNone: () => ({ state: Option.getOrElse(Array.get(unsettled, row.finished), () => "unknown") }),
+		onSome: (exit) => Exit.match(exit, {
+			onFailure: (cause) => ({
+				failure: failureOf(cause),
+				state: "failed"
+			}),
+			onSuccess: (value) => Option.match(decodeEnd(value), {
+				onNone: () => ({ state: "unknown" }),
+				onSome: endedWith
+			})
+		})
+	});
+};
+/** A row as a step; none when its start is not a step's, such as an activity of the app's own by that name. */
+const stepOf = (row) => Option.map(Option.flatMap(successOf(row.start), decodeStart), (start) => ({
+	command: start.command,
+	computer: start.computer,
+	job: row.job,
+	name: row.name,
+	startedAt: start.startedAt,
+	step: start.key,
+	timeoutSeconds: start.timeoutSeconds,
+	...settledOf(row)
+}));
+const withoutOutput = (step) => Struct.omit(step, [
+	"stderr",
+	"stdout",
+	"truncated"
+]);
+/** The actor's steps, newest first, without their output. */
+const stepsPage = ({ limit = 100, sql }) => Effect.map(sql.unsafe(stepRows("1"), [limit]), (rows) => Array.map(Array.getSomes(Array.map(rows, stepOf)), withoutOutput));
+/** One step by its key, with its output when it ran. */
+const stepByKey = ({ sql, step }) => Effect.map(sql.unsafe(stepRows("instr(start, ?) > 0"), [step, largestPage]), (rows) => Array.findFirst(Array.getSomes(Array.map(rows, stepOf)), (found) => found.step === step));
+export { stepByKey, stepsPage };

package/dist/host/computer/job-computers.service.d.mts

@@ -0,0 +1,20 @@
+import { ActorComputerClients } from "../../contract/computer/computer-client.adapter.mjs";
+import { Context, Effect, Layer } from "effect";
+type Clients = ActorComputerClients["Service"];
+declare const JobComputers_base: Context.ServiceClass<JobComputers, "@akterjs/effect/host/computer/job-computers.service/JobComputers", {
+  readonly bind: (clients: Clients) => Effect.Effect<void>;
+  readonly clients: Clients;
+}>;
+/**
+ * The computers a job runtime's activities reach through `Actor.computer(key)`: whichever the engine hosting the app
+ * bound last. Job handlers keep the context the app layer was built in, and the app is built before the engine that
+ * hosts it, so the engine binds its computers here once it knows where they live, as the local engine does for each
+ * environment it serves. Until one binds, every call fails with `ComputersUnavailableError`. `Akter.jobs` and
+ * `Akter.local` share one through the layer memo, as they share the job engine. Its layer gives the app these
+ * computers only while `AKTER_LOCAL_COMPUTERS` is on; off, it gives none, so computers another layer provides stay
+ * visible and `Actor.computer(key)` answers as on a host without computers.
+ */
+export declare class JobComputers extends JobComputers_base {
+  static readonly layer: Layer.Layer<JobComputers>;
+}
+export {};

package/dist/host/computer/job-computers.service.mjs

@@ -0,0 +1,59 @@
+import { ActorComputerClients } from "../../contract/computer/computer-client.adapter.mjs";
+import { ComputersUnavailableError } from "../../contract/computer/computers-unavailable.errors.mjs";
+import { Config, Context, Effect, Layer, Option, Ref } from "effect";
+// src/host/computer/job-computers.service.ts
+const unbound = ComputersUnavailableError.make({ message: "computers aren't available on this host" });
+/** Each operation reaches the clients bound when it runs, so a host bound after the app was built still answers. */
+const clientThrough = (current) => {
+	const connected = (address) => Effect.map(current, (clients) => clients.connect(address));
+	return (address) => {
+		const client = connected(address);
+		return {
+			ensure: (spec) => Effect.flatMap(client, (bound) => bound.ensure(spec)),
+			exec: (computer, request) => Effect.flatMap(client, (bound) => bound.exec(computer, request)),
+			files: (computer, request) => Effect.flatMap(client, (bound) => bound.files(computer, request)),
+			fork: (computer, fork) => Effect.flatMap(client, (bound) => bound.fork(computer, fork)),
+			get: (computer) => Effect.flatMap(client, (bound) => bound.get(computer)),
+			list: Effect.flatMap(client, (bound) => bound.list),
+			pause: (computer, hold) => Effect.flatMap(client, (bound) => bound.pause(computer, hold)),
+			remove: (computer) => Effect.flatMap(client, (bound) => bound.remove(computer)),
+			resume: (computer, hold) => Effect.flatMap(client, (bound) => bound.resume(computer, hold)),
+			stop: (computer) => Effect.flatMap(client, (bound) => bound.stop(computer))
+		};
+	};
+};
+/**
+* Whether the local engine runs computers: off unless `AKTER_LOCAL_COMPUTERS` is `true`, because a local computer runs
+* its steps on this machine. Off, the app's jobs see no computers, as before the local engine had them.
+*/
+const localComputersOn = Config.Boolean("AKTER_LOCAL_COMPUTERS").pipe(Config.withDefault(false));
+const make = Effect.gen(function* makeJobComputers() {
+	const bound = yield* Ref.make(Option.none());
+	const current = Effect.flatMap(Ref.get(bound), (found) => Effect.mapError(Effect.fromOption(found), () => unbound));
+	return {
+		bind: (host) => Ref.set(bound, Option.some(host)),
+		clients: ActorComputerClients.of({
+			connect: clientThrough(current),
+			logs: (address, computer, page) => Effect.flatMap(current, (found) => found.logs(address, computer, page))
+		})
+	};
+});
+/**
+* The computers a job runtime's activities reach through `Actor.computer(key)`: whichever the engine hosting the app
+* bound last. Job handlers keep the context the app layer was built in, and the app is built before the engine that
+* hosts it, so the engine binds its computers here once it knows where they live, as the local engine does for each
+* environment it serves. Until one binds, every call fails with `ComputersUnavailableError`. `Akter.jobs` and
+* `Akter.local` share one through the layer memo, as they share the job engine. Its layer gives the app these
+* computers only while `AKTER_LOCAL_COMPUTERS` is on; off, it gives none, so computers another layer provides stay
+* visible and `Actor.computer(key)` answers as on a host without computers.
+*/
+var JobComputers = class JobComputers extends Context.Service()("@akterjs/effect/host/computer/job-computers.service/JobComputers") {
+	static layer = Layer.effectContext(Effect.gen(function* buildJobComputers() {
+		const computers = yield* make;
+		const on = yield* Effect.orDie(localComputersOn);
+		const context = Context.make(JobComputers, computers);
+		if (!on) return context;
+		return Context.add(context, ActorComputerClients, computers.clients);
+	}));
+};
+export { JobComputers };

package/dist/host/computer/local-computer-files.layer.d.mts

@@ -0,0 +1,11 @@
+import { Failing, Place } from "./local-computer-records.layer.mjs";
+import { Effect, FileSystem, Path } from "effect";
+declare const localComputerFile: (place: Place, request: {
+  readonly _tag: "Read";
+  readonly path: string;
+} | {
+  readonly _tag: "Write";
+  readonly content: Uint8Array<ArrayBufferLike>;
+  readonly path: string;
+}) => Effect.Effect<Uint8Array<ArrayBuffer>, Failing, FileSystem.FileSystem | Path.Path>;
+export { localComputerFile };