@akterjs/effect 0.0.0-stage → 0.1.0

package/dist/host/computer/local-computer-files.layer.mjs

@@ -0,0 +1,69 @@
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import { computerFileBytes } from "../../contract/computer/files/computer-files.schema.mjs";
+import { filePathOf } from "../../contract/file/file-path.pure.mjs";
+import { notHeld, present, recordFor } from "./local-computer-records.layer.mjs";
+import { Array, Effect, FileSystem, Path, Predicate, Stream, String } from "effect";
+// src/host/computer/local-computer-files.layer.ts
+const extraByte = 1;
+const checkedPath = Effect.fnUntraced(function* checkedPath(disk, target, actor) {
+	const canonical = yield* (yield* FileSystem.FileSystem).realPath(target).pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(target)));
+	if (!String.startsWith(`${disk}/`)(canonical)) return yield* InvalidRequestError.make({
+		actor,
+		message: "a computer file must stay on its disk"
+	});
+	return target;
+});
+/** Check each existing ancestor before creating the next, so a symlink cannot make directories off the disk. */
+const targetOf = Effect.fnUntraced(function* targetOf(place, relative, writing) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const disk = yield* fs.realPath(place.disk);
+	const segments = ["files", ...String.split(relative, "/")];
+	const initial = Effect.succeed(disk);
+	return yield* Array.reduce(segments, initial, (previous, segment, index) => Effect.gen(function* checkChild() {
+		const parent = yield* previous;
+		const target = yield* checkedPath(disk, path.join(parent, segment), place.actor);
+		if (writing && index < segments.length - extraByte) yield* fs.makeDirectory(target).pipe(Effect.catchReason("PlatformError", "AlreadyExists", () => Effect.void));
+		return target;
+	}));
+});
+const readFile = Effect.fnUntraced(function* readFile(target, actor) {
+	const fs = yield* FileSystem.FileSystem;
+	const stat = yield* fs.stat(target);
+	if (stat.type !== "File" || stat.size > BigInt(1048576)) return yield* InvalidRequestError.make({
+		actor,
+		message: "a computer file must be a regular file of at most 1 MiB"
+	});
+	const chunks = yield* Stream.runCollect(fs.stream(target, { bytesToRead: computerFileBytes + extraByte }));
+	const content = Uint8Array.from(Array.flatMap(chunks, (chunk) => [...chunk]));
+	if (content.byteLength > 1048576) return yield* InvalidRequestError.make({
+		actor,
+		message: "a computer file holds at most 1 MiB"
+	});
+	return content;
+});
+const writeFile = Effect.fnUntraced(function* writeFile(target, content) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const temporary = yield* fs.makeTempFileScoped({ directory: path.dirname(target) });
+	yield* fs.writeFile(temporary, content);
+	yield* fs.rename(temporary, target);
+	return /* @__PURE__ */ new Uint8Array();
+}, Effect.scoped);
+const localComputerFile = Effect.fnUntraced(function* localComputerFile(place, request) {
+	const record = yield* recordFor(place);
+	yield* notHeld(record);
+	yield* present(place);
+	const relative = yield* Effect.mapError(filePathOf(request.path), (failure) => InvalidRequestError.make({
+		actor: place.actor,
+		message: failure.message
+	}));
+	if (Predicate.isTagged(request, "Write") && request.content.byteLength > 1048576) return yield* InvalidRequestError.make({
+		actor: place.actor,
+		message: "a computer file holds at most 1 MiB"
+	});
+	const target = yield* targetOf(place, relative, Predicate.isTagged(request, "Write"));
+	if (Predicate.isTagged(request, "Write")) return yield* writeFile(target, request.content);
+	return yield* readFile(target, place.actor);
+});
+export { localComputerFile };

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

@@ -0,0 +1,23 @@
+import { ComputerLogLine, ExecResult } from "../../contract/computer/computer.schema.mjs";
+import { Effect, FileSystem, Path, Schema } from "effect";
+/** Whose log: the actor's directory and the computer's name. A removed computer keeps its log. */
+interface LogPlace {
+  readonly actor: string;
+  readonly name: string;
+}
+type Level = ComputerLogLine["level"];
+type DiskError = Effect.Error<ReturnType<FileSystem.FileSystem["exists"]>>;
+type Logged<Value> = Effect.Effect<Value, DiskError | Schema.SchemaError, FileSystem.FileSystem>;
+interface LocalLog {
+  readonly note: (place: LogPlace, level: Level, message: string) => Logged<void>;
+  /** The lines after `after`, oldest first, at most `limit`. */
+  readonly page: (place: LogPlace, after: number, limit: number) => Logged<readonly ComputerLogLine[]>;
+  /** A step's key and outcome, never its output, which can carry anything the step printed. */
+  readonly step: (place: LogPlace, key: string, result: ExecResult) => Logged<void>;
+}
+/**
+ * Each computer's log as a JSON file beside the actor's computers, in a directory no computer name can take, keeping
+ * the newest 1,000 lines as the hosted engine does. Writes to one log go one at a time.
+ */
+declare const localLog: (path: Path.Path) => LocalLog;
+export { type LocalLog, type LogPlace, localLog };

package/dist/host/computer/local-computer-log.layer.mjs

@@ -0,0 +1,64 @@
+import { ExecRan, logPageLines } from "../../contract/computer/computer.schema.mjs";
+import { LogJson } from "./local-computer.schema.mjs";
+import { Array, Clock, Effect, FileSystem, MutableHashMap, Option, Schema, Semaphore } from "effect";
+// src/host/computer/local-computer-log.layer.ts
+const firstSeq = 1;
+const succeeded = 0;
+const oneAtATime = 1;
+const encodeLog = Schema.encodeEffect(LogJson);
+const decodeLog = Schema.decodeUnknownEffect(LogJson);
+const ran = Schema.is(ExecRan);
+const exitLevel = (code) => {
+	if (code === succeeded) return "info";
+	return "warn";
+};
+const stepLine = (key, result) => {
+	if (!ran(result)) return ["error", `step ${key}: started but no outcome was recorded`];
+	return Option.match(Option.fromUndefinedOr(result.exitCode), {
+		onNone: () => ["warn", `step ${key}: ended without an exit code`],
+		onSome: (code) => [exitLevel(code), `step ${key}: exit ${String(code)}`]
+	});
+};
+const read = (file) => FileSystem.FileSystem.use((fs) => fs.readFileString(file).pipe(Effect.flatMap(decodeLog), Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed([]))));
+const appended = Effect.fnUntraced(function* appended(path, file, line) {
+	const fs = yield* FileSystem.FileSystem;
+	const lines = yield* read(file);
+	const seq = Option.match(Array.last(lines), {
+		onNone: () => firstSeq,
+		onSome: (last) => last.seq + firstSeq
+	});
+	const at = yield* Clock.currentTimeMillis;
+	const text = yield* encodeLog(Array.takeRight(Array.append(lines, {
+		...line,
+		at,
+		seq
+	}), logPageLines));
+	yield* fs.makeDirectory(path.dirname(file), { recursive: true });
+	yield* fs.writeFileString(file, text);
+});
+/**
+* Each computer's log as a JSON file beside the actor's computers, in a directory no computer name can take, keeping
+* the newest 1,000 lines as the hosted engine does. Writes to one log go one at a time.
+*/
+const localLog = (path) => {
+	const locks = MutableHashMap.empty();
+	const fileOf = ({ actor, name }) => path.join(actor, ".logs", `${name}.json`);
+	const note = (place, level, message) => Effect.suspend(() => {
+		const file = fileOf(place);
+		const lock = Option.getOrElse(MutableHashMap.get(locks, file), () => Semaphore.makeUnsafe(oneAtATime));
+		MutableHashMap.set(locks, file, lock);
+		return lock.withPermit(appended(path, file, {
+			level,
+			message
+		}));
+	});
+	return {
+		note,
+		page: (place, after, limit) => Effect.map(read(fileOf(place)), (lines) => Array.take(Array.filter(lines, (line) => line.seq > after), limit)),
+		step: (place, key, result) => {
+			const [level, message] = stepLine(key, result);
+			return note(place, level, message);
+		}
+	};
+};
+export { localLog };

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

@@ -0,0 +1,190 @@
+import { ComputerClientFailure } from "../../contract/computer/computer-client-failure.contract.mjs";
+import { ComputerAddress } from "../../contract/computer/computer-client.contract.mjs";
+import { LocalComputerRecord } from "./local-computer.schema.mjs";
+import { Effect, FileSystem, Option, Path, Schema, Semaphore } from "effect";
+/** What the disk answers when it fails: the file system's own error. */
+type DiskError = Effect.Error<ReturnType<FileSystem.FileSystem["exists"]>>;
+type Failing = ComputerClientFailure | DiskError | Schema.SchemaError;
+type Recorded<Value> = Effect.Effect<Value, Failing, FileSystem.FileSystem>;
+/** Where the local computers of one store live. */
+interface Store {
+  /** One permit: a new computer is counted and made one at a time, so two at once can't pass the limit. */
+  readonly admission: Semaphore.Semaphore;
+  readonly path: Path.Path;
+  readonly root: string;
+}
+/** One computer's directory: its record, its disk and its steps, under its actor's directory. */
+interface Place {
+  readonly actor: string;
+  readonly directory: string;
+  readonly disk: string;
+  readonly name: string;
+  readonly record: string;
+  readonly steps: string;
+}
+/** An actor key as one path segment, as the store writes it: never empty, never only dots. */
+declare const keySegment: (key: string) => string;
+declare const placeOf: ({ path, root }: Store) => (address: ComputerAddress, name: string) => Place;
+declare const listed: (directory: string) => Effect.Effect<readonly string[], DiskError, FileSystem.FileSystem>;
+declare const findRecord: (place: Place) => Effect.Effect<Option.Option<{
+  readonly createdAt: number;
+  readonly hold?: {
+    readonly from: "paused" | "running" | "stopped";
+    readonly hold: string;
+  };
+  readonly spec: {
+    readonly egress: readonly string[];
+    readonly image: string;
+    readonly name: string & import("effect/Brand").Brand<"ComputerName">;
+    readonly secrets?: readonly {
+      readonly header: string;
+      readonly host: string;
+      readonly prefix?: string;
+      readonly secret: string;
+    }[];
+    readonly size: {
+      readonly memoryMib: number;
+      readonly vcpu: number;
+    };
+  };
+  readonly state: "paused" | "running" | "stopped";
+}>, import("effect/PlatformError").PlatformError | Schema.SchemaError, FileSystem.FileSystem>;
+declare const recordFor: (place: Place) => Recorded<LocalComputerRecord>;
+/** Writes the record beside the old one and renames it over, so a crash never leaves half a record. */
+declare const saveRecord: (place: Place, record: {
+  readonly createdAt: number;
+  readonly hold?: {
+    readonly from: "paused" | "running" | "stopped";
+    readonly hold: string;
+  };
+  readonly spec: {
+    readonly egress: readonly string[];
+    readonly image: string;
+    readonly name: string & import("effect/Brand").Brand<"ComputerName">;
+    readonly secrets?: readonly {
+      readonly header: string;
+      readonly host: string;
+      readonly prefix?: string;
+      readonly secret: string;
+    }[];
+    readonly size: {
+      readonly memoryMib: number;
+      readonly vcpu: number;
+    };
+  };
+  readonly state: "paused" | "running" | "stopped";
+}) => Effect.Effect<{
+  readonly createdAt: number;
+  readonly hold?: {
+    readonly from: "paused" | "running" | "stopped";
+    readonly hold: string;
+  };
+  readonly spec: {
+    readonly egress: readonly string[];
+    readonly image: string;
+    readonly name: string & import("effect/Brand").Brand<"ComputerName">;
+    readonly secrets?: readonly {
+      readonly header: string;
+      readonly host: string;
+      readonly prefix?: string;
+      readonly secret: string;
+    }[];
+    readonly size: {
+      readonly memoryMib: number;
+      readonly vcpu: number;
+    };
+  };
+  readonly state: "paused" | "running" | "stopped";
+}, import("effect/PlatformError").PlatformError | Schema.SchemaError, FileSystem.FileSystem>;
+declare const computerOf: (place: Place, record: {
+  readonly createdAt: number;
+  readonly hold?: {
+    readonly from: "paused" | "running" | "stopped";
+    readonly hold: string;
+  };
+  readonly spec: {
+    readonly egress: readonly string[];
+    readonly image: string;
+    readonly name: string & import("effect/Brand").Brand<"ComputerName">;
+    readonly secrets?: readonly {
+      readonly header: string;
+      readonly host: string;
+      readonly prefix?: string;
+      readonly secret: string;
+    }[];
+    readonly size: {
+      readonly memoryMib: number;
+      readonly vcpu: number;
+    };
+  };
+  readonly state: "paused" | "running" | "stopped";
+}) => Effect.Effect<{
+  readonly egress: readonly string[];
+  readonly image: string;
+  readonly name: string & import("effect/Brand").Brand<"ComputerName">;
+  readonly secrets?: readonly {
+    readonly header: string;
+    readonly host: string;
+    readonly prefix?: string;
+    readonly secret: string;
+  }[];
+  readonly size: {
+    readonly memoryMib: number;
+    readonly vcpu: number;
+  };
+  readonly state: "failed" | "gone" | "paused" | "running" | "starting" | "stopped";
+}, import("effect/PlatformError").PlatformError, FileSystem.FileSystem>;
+/** The computer's disk is there; one whose disk is gone is lost, never made again empty under its name. */
+declare const present: (place: Place) => Recorded<void>;
+declare const notHeld: (record: LocalComputerRecord) => Recorded<void>;
+declare const movedTo: (place: Place, record: {
+  readonly createdAt: number;
+  readonly hold?: {
+    readonly from: "paused" | "running" | "stopped";
+    readonly hold: string;
+  };
+  readonly spec: {
+    readonly egress: readonly string[];
+    readonly image: string;
+    readonly name: string & import("effect/Brand").Brand<"ComputerName">;
+    readonly secrets?: readonly {
+      readonly header: string;
+      readonly host: string;
+      readonly prefix?: string;
+      readonly secret: string;
+    }[];
+    readonly size: {
+      readonly memoryMib: number;
+      readonly vcpu: number;
+    };
+  };
+  readonly state: "paused" | "running" | "stopped";
+}, state: "paused" | "running" | "stopped") => Effect.Effect<{
+  readonly createdAt: number;
+  readonly hold?: {
+    readonly from: "paused" | "running" | "stopped";
+    readonly hold: string;
+  };
+  readonly spec: {
+    readonly egress: readonly string[];
+    readonly image: string;
+    readonly name: string & import("effect/Brand").Brand<"ComputerName">;
+    readonly secrets?: readonly {
+      readonly header: string;
+      readonly host: string;
+      readonly prefix?: string;
+      readonly secret: string;
+    }[];
+    readonly size: {
+      readonly memoryMib: number;
+      readonly vcpu: number;
+    };
+  };
+  readonly state: "paused" | "running" | "stopped";
+}, Failing, FileSystem.FileSystem>;
+/** Makes a new computer only while the store has room, counting and making under one permit. */
+declare const admitted: ({ computer, store }: {
+  readonly computer: string;
+  readonly store: Store;
+}) => <Value, Services>(making: Effect.Effect<Value, Failing, Services>) => Effect.Effect<Value, Failing, Services | FileSystem.FileSystem>;
+export { type DiskError, type Failing, type Place, type Recorded, type Store, admitted, computerOf, findRecord, keySegment, listed, movedTo, notHeld, placeOf, present, recordFor, saveRecord };

package/dist/host/computer/local-computer-records.layer.mjs

@@ -0,0 +1,99 @@
+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 { RecordJson } from "./local-computer.schema.mjs";
+import { Array, Effect, FileSystem, Option, Schema, String } from "effect";
+// src/host/computer/local-computer-records.layer.ts
+/** The computers one store keeps at most, the hosted engine's default store ceiling, so a dev app meets it locally. */
+const storeCeiling = 4;
+const recordFile = "computer.json";
+const dotsOnly = /^\.*$/u;
+const encodeRecord = Schema.encodeEffect(RecordJson);
+const decodeRecord = Schema.decodeUnknownEffect(RecordJson);
+/** An actor key as one path segment, as the store writes it: never empty, never only dots. */
+const keySegment = (key) => {
+	const encoded = encodeURIComponent(key);
+	if (String.isEmpty(encoded)) return "%";
+	if (dotsOnly.test(encoded)) return String.replaceAll(".", "%2E")(encoded);
+	return encoded;
+};
+const placeOf = ({ path, root }) => (address, name) => {
+	const actor = path.join(root, address.actor, keySegment(address.key));
+	const directory = path.join(actor, name);
+	return {
+		actor,
+		directory,
+		disk: path.join(directory, "disk"),
+		name,
+		record: path.join(directory, recordFile),
+		steps: path.join(directory, "steps")
+	};
+};
+const listed = (directory) => FileSystem.FileSystem.use((fs) => fs.readDirectory(directory).pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed([]))));
+const findRecord = Effect.fnUntraced(function* findRecord(place) {
+	const text = yield* (yield* FileSystem.FileSystem).readFileString(place.record).pipe(Effect.asSome, Effect.catchReason("PlatformError", "NotFound", () => Effect.succeedNone));
+	return yield* Option.match(text, {
+		onNone: () => Effect.succeed(Option.none()),
+		onSome: (found) => Effect.asSome(decodeRecord(found))
+	});
+});
+const recordFor = (place) => Effect.flatMap(findRecord(place), (found) => Effect.mapError(Effect.fromOption(found), () => ComputerNotFoundError.make({ computer: place.name })));
+/** Writes the record beside the old one and renames it over, so a crash never leaves half a record. */
+const saveRecord = Effect.fnUntraced(function* saveRecord(place, record) {
+	const fs = yield* FileSystem.FileSystem;
+	const staged = `${place.record}.next`;
+	const text = yield* encodeRecord(record);
+	yield* fs.writeFileString(staged, text);
+	yield* fs.rename(staged, place.record);
+	return record;
+});
+const stateOf = (record, present) => {
+	if (present) return record.state;
+	return "gone";
+};
+const computerOf = Effect.fnUntraced(function* computerOf(place, record) {
+	const found = yield* (yield* FileSystem.FileSystem).exists(place.disk);
+	return {
+		...record.spec,
+		state: stateOf(record, found)
+	};
+});
+/** The computer's disk is there; one whose disk is gone is lost, never made again empty under its name. */
+const present = (place) => FileSystem.FileSystem.use((fs) => Effect.flatMap(fs.exists(place.disk), (found) => {
+	if (found) return Effect.void;
+	return Effect.fail(ComputerLostError.make({ computer: place.name }));
+}));
+const notHeld = (record) => Option.match(Option.fromUndefinedOr(record.hold), {
+	onNone: () => Effect.void,
+	onSome: ({ hold }) => Effect.fail(ComputerHeldError.make({
+		computer: record.spec.name,
+		hold
+	}))
+});
+const movedTo = Effect.fnUntraced(function* movedTo(place, record, state) {
+	yield* present(place);
+	return yield* saveRecord(place, {
+		...record,
+		state
+	});
+});
+/** Every computer the store keeps, of every actor. */
+const keptIn = Effect.fnUntraced(function* keptIn({ path, root }) {
+	const fs = yield* FileSystem.FileSystem;
+	const under = (directory) => Effect.map(listed(directory), Array.map((entry) => path.join(directory, entry)));
+	const actors = yield* under(root);
+	const keys = yield* Effect.forEach(actors, under);
+	const computers = yield* Effect.forEach(Array.flatten(keys), under);
+	return yield* Effect.filter(Array.flatten(computers), (computer) => fs.exists(path.join(computer, recordFile)));
+});
+/** Makes a new computer only while the store has room, counting and making under one permit. */
+const admitted = ({ computer, store }) => (making) => store.admission.withPermit(Effect.gen(function* admitComputer() {
+	if ((yield* keptIn(store)).length >= storeCeiling) return yield* ComputerLimitError.make({
+		computer,
+		limit: "store",
+		maximum: storeCeiling
+	});
+	return yield* making;
+}));
+export { admitted, computerOf, findRecord, keySegment, listed, movedTo, notHeld, placeOf, present, recordFor, saveRecord };

package/dist/host/computer/local-computer.schema.d.mts

@@ -0,0 +1,69 @@
+import { Schema } from "effect";
+/** A local computer's power state. It has no starting phase: a new one is running once it is made. */
+declare const LocalState: Schema.Literals<readonly ["running", "paused", "stopped"]>;
+type LocalState = typeof LocalState.Type;
+/**
+ * One local computer as its directory records it: the spec it keeps, where it is, and the hold a fork may keep on it.
+ */
+declare const LocalComputerRecord: Schema.Struct<{
+  readonly createdAt: Schema.Int;
+  readonly hold: Schema.optionalKey<Schema.Struct<{
+    readonly from: Schema.Literals<readonly ["running", "paused", "stopped"]>;
+    readonly hold: Schema.String;
+  }>>;
+  readonly spec: Schema.Struct<{
+    readonly egress: Schema.$Array<Schema.String>;
+    readonly image: Schema.String;
+    readonly name: Schema.brand<Schema.String, "ComputerName">;
+    readonly secrets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+      readonly header: Schema.String;
+      readonly host: Schema.String;
+      readonly prefix: Schema.optionalKey<Schema.String>;
+      readonly secret: Schema.String;
+    }>>>;
+    readonly size: Schema.Struct<{
+      readonly memoryMib: Schema.Int;
+      readonly vcpu: Schema.Int;
+    }>;
+  }>;
+  readonly state: Schema.Literals<readonly ["running", "paused", "stopped"]>;
+}>;
+type LocalComputerRecord = typeof LocalComputerRecord.Type;
+declare const RecordJson: Schema.fromJsonString<Schema.Struct<{
+  readonly createdAt: Schema.Int;
+  readonly hold: Schema.optionalKey<Schema.Struct<{
+    readonly from: Schema.Literals<readonly ["running", "paused", "stopped"]>;
+    readonly hold: Schema.String;
+  }>>;
+  readonly spec: Schema.Struct<{
+    readonly egress: Schema.$Array<Schema.String>;
+    readonly image: Schema.String;
+    readonly name: Schema.brand<Schema.String, "ComputerName">;
+    readonly secrets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+      readonly header: Schema.String;
+      readonly host: Schema.String;
+      readonly prefix: Schema.optionalKey<Schema.String>;
+      readonly secret: Schema.String;
+    }>>>;
+    readonly size: Schema.Struct<{
+      readonly memoryMib: Schema.Int;
+      readonly vcpu: Schema.Int;
+    }>;
+  }>;
+  readonly state: Schema.Literals<readonly ["running", "paused", "stopped"]>;
+}>>;
+declare const LogJson: Schema.fromJsonString<Schema.$Array<Schema.Struct<{
+  readonly at: Schema.Int;
+  readonly level: Schema.Literals<readonly ["info", "warn", "error"]>;
+  readonly message: Schema.String;
+  readonly seq: Schema.Int;
+}>>>;
+/** A step's recorded end: its exit code, or none when it was ended without one, such as at its time limit. */
+declare const StepStatus: Schema.Struct<{
+  readonly exitCode: Schema.optionalKey<Schema.Int>;
+}>;
+type StepStatus = typeof StepStatus.Type;
+declare const StatusJson: Schema.fromJsonString<Schema.Struct<{
+  readonly exitCode: Schema.optionalKey<Schema.Int>;
+}>>;
+export { LocalComputerRecord, LocalState, LogJson, RecordJson, StatusJson, StepStatus };

package/dist/host/computer/local-computer.schema.mjs

@@ -0,0 +1,29 @@
+import { ComputerLogLine, ComputerSpec } from "../../contract/computer/computer.schema.mjs";
+import { Schema } from "effect";
+// src/host/computer/local-computer.schema.ts
+/** A local computer's power state. It has no starting phase: a new one is running once it is made. */
+const LocalState = Schema.Literals([
+	"running",
+	"paused",
+	"stopped"
+]);
+/** A hold records where its pause found the computer, so the hold's resume returns it there. */
+const Hold = Schema.Struct({
+	from: LocalState,
+	hold: Schema.String
+});
+/**
+* One local computer as its directory records it: the spec it keeps, where it is, and the hold a fork may keep on it.
+*/
+const LocalComputerRecord = Schema.Struct({
+	createdAt: Schema.Int,
+	hold: Schema.optionalKey(Hold),
+	spec: ComputerSpec,
+	state: LocalState
+});
+const RecordJson = Schema.fromJsonString(LocalComputerRecord);
+const LogJson = Schema.fromJsonString(Schema.Array(ComputerLogLine));
+/** A step's recorded end: its exit code, or none when it was ended without one, such as at its time limit. */
+const StepStatus = Schema.Struct({ exitCode: Schema.optionalKey(Schema.Int) });
+const StatusJson = Schema.fromJsonString(StepStatus);
+export { LocalComputerRecord, LocalState, LogJson, RecordJson, StatusJson, StepStatus };

package/dist/host/computer/local-computers.adapter.d.mts

@@ -0,0 +1,18 @@
+import { ComputerLogLine, ComputerLogPage } from "../../contract/computer/computer.schema.mjs";
+import { ComputerClientFailure } from "../../contract/computer/computer-client-failure.contract.mjs";
+import { ComputerAddress, ComputerClient } from "../../contract/computer/computer-client.contract.mjs";
+import { Failing } from "./local-computer-records.layer.mjs";
+import { StepServices } from "./local-step.layer.mjs";
+import { Context, Effect, FileSystem, Path } from "effect";
+declare const LocalComputers_base: Context.ServiceClass<LocalComputers, "@akterjs/effect/host/computer/local-computers.adapter/LocalComputers", {
+  readonly connect: (address: ComputerAddress) => ComputerClient;
+  readonly logs: (address: ComputerAddress, computer: string, page: ComputerLogPage) => Effect.Effect<readonly ComputerLogLine[], ComputerClientFailure>;
+}>;
+export declare class LocalComputers extends LocalComputers_base {
+  static readonly make: (root: string) => Effect.Effect<{
+    readonly connect: (address: ComputerAddress) => ComputerClient;
+    readonly logs: (address: ComputerAddress, computer: string, page: ComputerLogPage) => Effect.Effect<readonly ComputerLogLine[], ComputerClientFailure>;
+  }, never, StepServices>;
+  static readonly remove: (root: string, address: ComputerAddress) => Effect.Effect<void, Failing, FileSystem.FileSystem | Path.Path>;
+}
+export {};