@akterjs/effect 0.1.2 → 0.1.4

package/dist/contract/computer/computer-limit.errors.d.mts

@@ -7,9 +7,9 @@ declare const ComputerLimitError_base: Schema.Class<ComputerLimitError, Schema.T
   readonly brand: unique symbol;
 }>;
 /**
- * A new computer would pass a limit, so none was made: `store`, the computers one app environment may keep, or
- * `account`, the sandboxes the platform's provider account may run at once. Remove a computer, or try again once
- * one is gone. Nothing waits for room.
+ * A new computer was refused for capacity, so none was made: `account`, the sandboxes the platform's provider account
+ * may run at once, with the most it holds. Try again once one is free; nothing waits for room. `store`, the computers
+ * one app environment may keep, is no longer set by Akter Cloud or the local engine; older engines may still send it.
  */
 export declare class ComputerLimitError extends ComputerLimitError_base {}
 export {};

package/dist/contract/computer/computer-limit.errors.mjs

@@ -1,9 +1,9 @@
 import { Schema } from "effect";
 // src/contract/computer/computer-limit.errors.ts
 /**
-* A new computer would pass a limit, so none was made: `store`, the computers one app environment may keep, or
-* `account`, the sandboxes the platform's provider account may run at once. Remove a computer, or try again once
-* one is gone. Nothing waits for room.
+* A new computer was refused for capacity, so none was made: `account`, the sandboxes the platform's provider account
+* may run at once, with the most it holds. Try again once one is free; nothing waits for room. `store`, the computers
+* one app environment may keep, is no longer set by Akter Cloud or the local engine; older engines may still send it.
 */
 var ComputerLimitError = class extends Schema.TaggedError()("ComputerLimitError", {
 	computer: Schema.String,

package/dist/contract/computer/files/computer-files.schema.d.mts

@@ -1,14 +1,29 @@
 import { Schema } from "effect";
-/** One file per call, bounded before crossing the host/control link. Paths are relative to the computer's files directory. */
+/** The most one call carries across the host/control link. Paths are relative to the computer's files directory. */
 declare const computerFileBytes = 1048576;
+/**
+ * A file of any size moves in pieces: `ReadAt` answers at most `computerFileBytes` from `offset`, fewer at the end of
+ * the file, and `WriteAt` at offset 0 replaces the file, and at a later offset cuts it to that length and appends, so
+ * a resent piece is written once. `Read` and `Write` move a whole file of at most `computerFileBytes` in one call, as
+ * engines before pieces did; they stay so a host and a control plane of different releases still copy small files.
+ */
 declare const ComputerFileRequest: Schema.TaggedUnion<{
   readonly Read: Schema.TaggedStruct<"Read", {
     readonly path: Schema.String;
   }>;
+  readonly ReadAt: Schema.TaggedStruct<"ReadAt", {
+    readonly offset: Schema.Int;
+    readonly path: Schema.String;
+  }>;
   readonly Write: Schema.TaggedStruct<"Write", {
     readonly content: Schema.Uint8ArrayFromBase64;
     readonly path: Schema.String;
   }>;
+  readonly WriteAt: Schema.TaggedStruct<"WriteAt", {
+    readonly content: Schema.Uint8ArrayFromBase64;
+    readonly offset: Schema.Int;
+    readonly path: Schema.String;
+  }>;
 }>;
 type ComputerFileRequest = typeof ComputerFileRequest.Type;
 declare const ComputerCopy: Schema.Struct<{

package/dist/contract/computer/files/computer-files.schema.mjs

@@ -1,12 +1,28 @@
 import { Schema } from "effect";
 // src/contract/computer/files/computer-files.schema.ts
-/** One file per call, bounded before crossing the host/control link. Paths are relative to the computer's files directory. */
+/** The most one call carries across the host/control link. Paths are relative to the computer's files directory. */
 const computerFileBytes = 1048576;
+const Offset = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+/**
+* A file of any size moves in pieces: `ReadAt` answers at most `computerFileBytes` from `offset`, fewer at the end of
+* the file, and `WriteAt` at offset 0 replaces the file, and at a later offset cuts it to that length and appends, so
+* a resent piece is written once. `Read` and `Write` move a whole file of at most `computerFileBytes` in one call, as
+* engines before pieces did; they stay so a host and a control plane of different releases still copy small files.
+*/
 const ComputerFileRequest = Schema.TaggedUnion({
 	Read: { path: Schema.String },
+	ReadAt: {
+		offset: Offset,
+		path: Schema.String
+	},
 	Write: {
 		content: Schema.Uint8ArrayFromBase64,
 		path: Schema.String
+	},
+	WriteAt: {
+		content: Schema.Uint8ArrayFromBase64,
+		offset: Offset,
+		path: Schema.String
 	}
 });
 const ComputerCopy = Schema.Struct({

package/dist/host/command/batch/command-batch.sql.d.mts

@@ -15,7 +15,7 @@ interface Journal {
   readonly known: HashSet.HashSet<string>;
   readonly nextSeq: number;
   readonly recorded: HashMap.HashMap<string, RecordedCommand>;
-  /** The seq each command recorded in this batch was given. */
+  /** The seq of each command the journal answers for and that has one: read at the start, or given in this batch. */
   readonly seqs: HashMap.HashMap<string, number>;
   readonly state: Option.Option<string>;
 }
@@ -37,8 +37,11 @@ declare const CommandBatchJournal: {
   readonly recorded: (sql: SqlClient.SqlClient, commandId: string, read: Effect.Effect<Option.Option<RecordedCommand>, SqlError.SqlError>) => Effect.Effect<Option.Option<RecordedCommand>, SqlError.SqlError>;
   /** Notes a state the running command saved. */
   readonly saved: (value: string) => Effect.Effect<void>;
-  /** The seq a command recorded in this batch was given, or none when the batch did not record it. */
-  readonly seq: (commandId: string) => Effect.Effect<Option.Option<number>>;
+  /**
+   * The seq `commandId` was journaled with, from the batch journal when it answers for the id, so a command's check
+   * whether it already ran costs no round trip of its own.
+   */
+  readonly seq: (sql: SqlClient.SqlClient, commandId: string, read: Effect.Effect<Option.Option<number>, SqlError.SqlError>) => Effect.Effect<Option.Option<number>, SqlError.SqlError>;
   /** The actor's current state, from the batch journal when there is one. */
   readonly state: (sql: SqlClient.SqlClient, read: Effect.Effect<Option.Option<string>, SqlError.SqlError>) => Effect.Effect<Option.Option<string>, SqlError.SqlError>;
   /** The client for the running command's journal and state writes: the batch's held client, or `sql` itself. */

package/dist/host/command/batch/command-batch.sql.mjs

@@ -4,7 +4,7 @@ const CommandBatch = Context.Reference("@akterjs/effect/host/command/batch/comma
 const firstSeq = 1;
 const nextOf = 1;
 const IdList = Schema.fromJsonString(Schema.Array(Schema.String));
-const journalRows = (sql, ids) => sql`SELECT command_id AS "commandId", command, exit, principal FROM akter_commands WHERE command_id IN (SELECT value FROM json_each(${ids}))`;
+const journalRows = (sql, ids) => sql`SELECT command_id AS "commandId", command, exit, principal, seq FROM akter_commands WHERE command_id IN (SELECT value FROM json_each(${ids}))`;
 const readJournal = Effect.fnUntraced(function* readJournal(sql, commandIds) {
 	const ids = yield* Effect.orDie(Schema.encodeEffect(IdList)(commandIds));
 	const [states, rows, last] = yield* Effect.all([
@@ -18,8 +18,8 @@ const readJournal = Effect.fnUntraced(function* readJournal(sql, commandIds) {
 			onNone: () => firstSeq,
 			onSome: (row) => row.seq + nextOf
 		}),
-		recorded: HashMap.fromIterable(Array.map(rows, ({ commandId, ...recorded }) => [commandId, recorded])),
-		seqs: HashMap.empty(),
+		recorded: HashMap.fromIterable(Array.map(rows, ({ commandId, seq: _seq, ...recorded }) => [commandId, recorded])),
+		seqs: HashMap.fromIterable(Array.map(rows, ({ commandId, seq }) => [commandId, seq])),
 		state: Option.map(Array.head(states), (row) => row.value)
 	};
 });
@@ -66,10 +66,13 @@ const CommandBatchJournal = {
 		...journal,
 		state: Option.some(value)
 	})),
-	/** The seq a command recorded in this batch was given, or none when the batch did not record it. */
-	seq: (commandId) => Effect.flatMap(CommandBatch, (batch) => Option.match(batch, {
-		onNone: () => Effect.succeedNone,
-		onSome: (open) => Effect.map(Ref.get(open.current), Option.flatMap((journal) => HashMap.get(journal.seqs, commandId)))
+	/**
+	* The seq `commandId` was journaled with, from the batch journal when it answers for the id, so a command's check
+	* whether it already ran costs no round trip of its own.
+	*/
+	seq: (sql, commandId, read) => Effect.flatMap(journalOf(sql), (opened) => Option.match(Option.filter(opened, ([, journal]) => answers(journal, commandId)), {
+		onNone: () => read,
+		onSome: ([, journal]) => Effect.succeed(HashMap.get(journal.seqs, commandId))
 	})),
 	/** The actor's current state, from the batch journal when there is one. */
 	state: (sql, read) => Effect.flatMap(journalOf(sql), Option.match({

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

@@ -3,9 +3,18 @@ import { Effect, FileSystem, Path } from "effect";
 declare const localComputerFile: (place: Place, request: {
   readonly _tag: "Read";
   readonly path: string;
+} | {
+  readonly _tag: "ReadAt";
+  readonly offset: number;
+  readonly path: string;
 } | {
   readonly _tag: "Write";
   readonly content: Uint8Array<ArrayBufferLike>;
   readonly path: string;
-}) => Effect.Effect<Uint8Array<ArrayBuffer>, Failing, FileSystem.FileSystem | Path.Path>;
+} | {
+  readonly _tag: "WriteAt";
+  readonly content: Uint8Array<ArrayBufferLike>;
+  readonly offset: number;
+  readonly path: string;
+}) => Effect.Effect<Uint8Array<ArrayBufferLike>, Failing, FileSystem.FileSystem | Path.Path>;
 export { localComputerFile };

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

@@ -1,10 +1,11 @@
 import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
-import { computerFileBytes } from "../../contract/computer/files/computer-files.schema.mjs";
+import { ComputerFileRequest, 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 fileStart = 0;
 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({
@@ -27,6 +28,14 @@ const targetOf = Effect.fnUntraced(function* targetOf(place, relative, writing)
 		return target;
 	}));
 });
+const joined = (chunks) => {
+	const bytes = new Uint8Array(Array.reduce(chunks, fileStart, (total, chunk) => total + chunk.byteLength));
+	Array.reduce(chunks, fileStart, (offset, chunk) => {
+		bytes.set(chunk, offset);
+		return offset + chunk.byteLength;
+	});
+	return bytes;
+};
 const readFile = Effect.fnUntraced(function* readFile(target, actor) {
 	const fs = yield* FileSystem.FileSystem;
 	const stat = yield* fs.stat(target);
@@ -35,13 +44,26 @@ const readFile = Effect.fnUntraced(function* readFile(target, 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]));
+	const content = joined(chunks);
 	if (content.byteLength > 1048576) return yield* InvalidRequestError.make({
 		actor,
 		message: "a computer file holds at most 1 MiB"
 	});
 	return content;
 });
+/** At most one call's bytes from `offset`; fewer at the end of the file. */
+const readPiece = Effect.fnUntraced(function* readPiece(target, offset, actor) {
+	const fs = yield* FileSystem.FileSystem;
+	if ((yield* fs.stat(target)).type !== "File") return yield* InvalidRequestError.make({
+		actor,
+		message: "a computer file must be a regular file"
+	});
+	const chunks = yield* Stream.runCollect(fs.stream(target, {
+		bytesToRead: computerFileBytes,
+		offset
+	}));
+	return joined(chunks);
+});
 const writeFile = Effect.fnUntraced(function* writeFile(target, content) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -50,6 +72,18 @@ const writeFile = Effect.fnUntraced(function* writeFile(target, content) {
 	yield* fs.rename(temporary, target);
 	return /* @__PURE__ */ new Uint8Array();
 }, Effect.scoped);
+/** At offset 0 the piece replaces the file; later, the file is cut to `offset` and the piece appended. */
+const writePiece = Effect.fnUntraced(function* writePiece(target, { actor, content, offset }) {
+	if (offset === fileStart) return yield* writeFile(target, content);
+	const fs = yield* FileSystem.FileSystem;
+	if ((yield* fs.stat(target)).size < BigInt(offset)) return yield* InvalidRequestError.make({
+		actor,
+		message: "a piece must follow the bytes already written"
+	});
+	yield* fs.truncate(target, offset);
+	yield* fs.writeFile(target, content, { flag: "a" });
+	return /* @__PURE__ */ new Uint8Array();
+});
 const localComputerFile = Effect.fnUntraced(function* localComputerFile(place, request) {
 	const record = yield* recordFor(place);
 	yield* notHeld(record);
@@ -58,12 +92,21 @@ const localComputerFile = Effect.fnUntraced(function* localComputerFile(place, r
 		actor: place.actor,
 		message: failure.message
 	}));
-	if (Predicate.isTagged(request, "Write") && request.content.byteLength > 1048576) return yield* InvalidRequestError.make({
+	const writing = Predicate.isTagged(request, "Write") || Predicate.isTagged(request, "WriteAt");
+	if (writing && request.content.byteLength > 1048576) return yield* InvalidRequestError.make({
 		actor: place.actor,
-		message: "a computer file holds at most 1 MiB"
+		message: "a computer file call carries at most 1 MiB"
+	});
+	const target = yield* targetOf(place, relative, writing);
+	return yield* ComputerFileRequest.match(request, {
+		Read: () => readFile(target, place.actor),
+		ReadAt: ({ offset }) => readPiece(target, offset, place.actor),
+		Write: ({ content }) => writeFile(target, content),
+		WriteAt: ({ content, offset }) => writePiece(target, {
+			actor: place.actor,
+			content,
+			offset
+		})
 	});
-	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-records.layer.d.mts

@@ -1,15 +1,13 @@
 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";
+import { Effect, FileSystem, Option, Path, Schema } 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;
 }
@@ -182,9 +180,4 @@ declare const movedTo: (place: Place, record: {
   };
   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 };
+export { type DiskError, type Failing, type Place, type Recorded, type Store, computerOf, findRecord, keySegment, listed, movedTo, notHeld, placeOf, present, recordFor, saveRecord };

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

@@ -1,12 +1,9 @@
 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";
+import { 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);
@@ -78,22 +75,4 @@ const movedTo = Effect.fnUntraced(function* movedTo(place, record, state) {
 		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 };
+export { computerOf, findRecord, keySegment, listed, movedTo, notHeld, placeOf, present, recordFor, saveRecord };

package/dist/host/computer/local-computers.adapter.mjs

@@ -3,7 +3,7 @@ import { ComputerHeldError } from "../../contract/computer/computer-held.errors.
 import { ComputersUnavailableError } from "../../contract/computer/computers-unavailable.errors.mjs";
 import "../../contract/computer/computer.schema.mjs";
 import { localLog } from "./local-computer-log.layer.mjs";
-import { admitted, computerOf, findRecord, keySegment, listed, movedTo, notHeld, placeOf, present, recordFor, saveRecord } from "./local-computer-records.layer.mjs";
+import { computerOf, findRecord, keySegment, listed, movedTo, notHeld, placeOf, present, recordFor, saveRecord } from "./local-computer-records.layer.mjs";
 import { runStep } from "./local-step.layer.mjs";
 import { localComputerFile } from "./local-computer-files.layer.mjs";
 import { Array, Clock, Context, Effect, FileSystem, MutableHashMap, Option, Path, Semaphore, String as String$1 } from "effect";
@@ -38,10 +38,7 @@ const made = Effect.fnUntraced(function* made(local, place, spec) {
 });
 /** An existing computer keeps its image and size and takes the new spec's egress and secrets. */
 const ensureIn = (local, place, spec) => Effect.flatMap(findRecord(place), (found) => Option.match(found, {
-	onNone: () => admitted({
-		computer: spec.name,
-		store: local
-	})(made(local, place, spec)),
+	onNone: () => made(local, place, spec),
 	onSome: (record) => Effect.gen(function* ensureExisting() {
 		yield* notHeld(record);
 		yield* present(place);
@@ -164,13 +161,10 @@ const forkIn = (local, place, fork) => Effect.gen(function* forkComputer() {
 	const existing = yield* findRecord(target);
 	if (Option.isSome(existing)) return yield* computerOf(target, existing.value);
 	yield* present(place);
-	const forked = yield* admitted({
-		computer: name,
-		store: local
-	})(copied(place, target, {
+	const forked = yield* copied(place, target, {
 		...record.spec,
 		name
-	}));
+	});
 	yield* local.log.note(place, "info", `forked into ${fork.into.actor}/${fork.into.key}${heldNote(fork.name, "as")}`);
 	return yield* computerOf(target, forked);
 });
@@ -219,7 +213,6 @@ const clientFor = (local, answered) => (address) => {
 const localAt = Effect.fnUntraced(function* localAt(root) {
 	const path = yield* Path.Path;
 	return {
-		admission: yield* Semaphore.make(onePermit),
 		locks: MutableHashMap.empty(),
 		log: localLog(path),
 		path,

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

@@ -1,18 +1,14 @@
 import { ActorUnavailableError } from "../../contract/client/actor-unavailable.errors.mjs";
-import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
 import { ActorComputerClients } from "../../contract/computer/computer-client.adapter.mjs";
 import { localLog } from "../computer/local-computer-log.layer.mjs";
-import { admitted, findRecord, listed, placeOf, saveRecord } from "../computer/local-computer-records.layer.mjs";
-import { Array, Clock, Context, Effect, FileSystem, Layer, Match, Option, Path, Semaphore, String as String$1 } from "effect";
+import { findRecord, listed, placeOf, saveRecord } from "../computer/local-computer-records.layer.mjs";
+import { Array, Clock, Context, Effect, FileSystem, Layer, Match, Option, Path, String } from "effect";
 // src/host/fork/fork-computers.adapter.ts
 const markPrefix = "@fork-";
-const oneAtATime = 1;
 const markOf = (fork) => `${markPrefix}${encodeURIComponent(fork)}`;
 const storeOf = Effect.fnUntraced(function* storeOf(root) {
-	const path = yield* Path.Path;
 	return {
-		admission: yield* Semaphore.make(oneAtATime),
-		path,
+		path: yield* Path.Path,
 		root
 	};
 });
@@ -22,10 +18,6 @@ const failedWith = (actor) => (failure) => Match.value(failure).pipe(Match.tags(
 		actor,
 		message: `${actor} can't fork while its computer ${computer} is held by ${hold}, a fork that didn't finish. Retry that fork, or resume the computer with the hold ${hold}, to release it.`
 	}),
-	ComputerLimitError: ({ maximum }) => InvalidRequestError.make({
-		actor,
-		message: `${actor} can't fork: copying its computers would pass the store's limit of ${String(maximum)} computers. Remove a computer, then fork again.`
-	}),
 	InvalidRequestError: (invalid) => invalid
 }), Match.orElse(() => ActorUnavailableError.make({
 	actor,
@@ -36,7 +28,7 @@ const foundIn = (place) => Effect.map(findRecord(place), Option.map(() => ({ pla
 /** The parent's computers as their directories record them, by name. */
 const parentComputers = Effect.fnUntraced(function* parentComputers(store, parent) {
 	const names = yield* listed(placeOf(store)(parent, "").actor);
-	const places = Array.map(Array.sort(names, String$1.Order), (name) => placeOf(store)(parent, name));
+	const places = Array.map(Array.sort(names, String.Order), (name) => placeOf(store)(parent, name));
 	const found = yield* Effect.forEach(places, foundIn);
 	return Array.getSomes(found);
 });
@@ -81,10 +73,7 @@ const copied = (store, { child, fork, parent }) => ({ name }) => {
 	const source = placeOf(store)(parent, name);
 	const target = placeOf(store)(child, name);
 	const note = `copied from ${parent.actor}/${parent.key} by the fork ${fork}, stopped`;
-	return Effect.andThen(admitted({
-		computer: name,
-		store
-	})(copyOne(source, target)), localLog(store.path).note(target, "info", note));
+	return Effect.andThen(copyOne(source, target), localLog(store.path).note(target, "info", note));
 };
 const alreadyKept = ({ child, parent }) => ActorUnavailableError.make({
 	actor: parent.actor,
@@ -142,7 +131,7 @@ const discardComputers = (forking) => answered(forking.parent.actor)(Effect.gen(
 	const store = yield* storeOf(forking.root);
 	const directory = placeOf(store)(forking.child, "").actor;
 	const names = yield* listed(directory);
-	if (Array.some(names, String$1.startsWith(markPrefix))) yield* fs.remove(directory, {
+	if (Array.some(names, String.startsWith(markPrefix))) yield* fs.remove(directory, {
 		force: true,
 		recursive: true
 	});
@@ -151,7 +140,7 @@ const discardComputers = (forking) => answered(forking.parent.actor)(Effect.gen(
 const sweptPath = (path, root, stored) => (entry) => {
 	const mark = path.join(root, entry);
 	const owner = path.dirname(mark);
-	if (stored.has(String$1.replaceAll(path.sep, "/")(path.relative(root, owner)))) return mark;
+	if (stored.has(String.replaceAll(path.sep, "/")(path.relative(root, owner)))) return mark;
 	return owner;
 };
 /**

package/dist/serve/live/live-tables.sql.d.mts

@@ -25,7 +25,7 @@ interface CommandAt {
   readonly commandId: string;
   readonly reader: SqlClient.SqlClient;
 }
-/** A command recorded in the running engine batch has its seq in the batch journal; any other is read. */
+/** A command the running engine batch's journal answers for has its seq there; any other is read. */
 declare const commandVersion: (at: CommandAt) => Sql<Option.Option<number>>;
 /**
  * When a command recorded in the journal ran, in epoch milliseconds. One the running engine batch recorded, which is

package/dist/serve/live/live-tables.sql.mjs

@@ -53,11 +53,8 @@ const committedVersion = (reader) => Effect.map(reader`SELECT COALESCE(MAX(seq),
 	onSome: (row) => row.version
 }));
 const recordedVersion = ({ commandId, reader }) => Effect.map(reader`SELECT seq FROM akter_commands WHERE command_id = ${commandId}`, (rows) => Option.map(Array.head(rows), (row) => row.seq));
-/** A command recorded in the running engine batch has its seq in the batch journal; any other is read. */
-const commandVersion = (at) => Effect.flatMap(CommandBatchJournal.seq(at.commandId), (seq) => Option.match(seq, {
-	onNone: () => recordedVersion(at),
-	onSome: () => Effect.succeed(seq)
-}));
+/** A command the running engine batch's journal answers for has its seq there; any other is read. */
+const commandVersion = (at) => CommandBatchJournal.seq(at.reader, at.commandId, recordedVersion(at));
 /**
 * When a command recorded in the journal ran, in epoch milliseconds. One the running engine batch recorded, which is
 * not in the journal yet, has none: it ran moments ago.

package/dist/serve/rpc/computer/computer-copy.layer.mjs

@@ -1,36 +1,59 @@
 import { CurrentCaller } from "../../../contract/caller/current-caller.service.mjs";
 import { InvalidRequestError } from "../../../contract/client/invalid-request.errors.mjs";
-import { ComputerFileRequest } from "../../../contract/computer/files/computer-files.schema.mjs";
+import { ComputerFileRequest, computerFileBytes } from "../../../contract/computer/files/computer-files.schema.mjs";
 import { filePathOf } from "../../../contract/file/file-path.pure.mjs";
 import { hostFileClient } from "../../../runtime/local-file-clients.layer.mjs";
 import { ownerOf } from "../file/file-rpc-access.pure.mjs";
-import { Boolean, Effect, Predicate, Stream } from "effect";
+import { Array, Boolean, Effect, Option, Predicate, Ref, Stream } from "effect";
 // src/serve/rpc/computer/computer-copy.layer.ts
 const invalid = (actor, message) => InvalidRequestError.make({
 	actor,
 	message
 });
-const collect = (actor, source) => Stream.runFoldEffect(source, () => /* @__PURE__ */ new Uint8Array(), (before, chunk) => {
-	if (before.byteLength + chunk.byteLength > 1048576) return Effect.fail(invalid(actor, "a computer file holds at most 1 MiB"));
-	const joined = new Uint8Array(before.byteLength + chunk.byteLength);
+const nothing = 0;
+const next = 1;
+const concatenated = (before, after) => {
+	const joined = new Uint8Array(before.byteLength + after.byteLength);
 	joined.set(before);
-	joined.set(chunk, before.byteLength);
-	return Effect.succeed(joined);
-});
-const transfer = Effect.fnUntraced(function* transfer({ actor, client, request }, files) {
+	joined.set(after, before.byteLength);
+	return joined;
+};
+/**
+* The file's bytes as the pieces one call carries: whole pieces of `computerFileBytes`, then what is left, and one
+* empty piece for an empty file, so writing it still makes the file.
+*/
+const piecesOf = (source) => Stream.mapAccum(source, () => ({
+	pending: /* @__PURE__ */ new Uint8Array(),
+	sent: false
+}), ({ pending, sent }, chunk) => {
+	const bytes = concatenated(pending, chunk);
+	const whole = Math.floor(bytes.byteLength / computerFileBytes);
+	const pieces = Boolean.match(whole > nothing, {
+		onFalse: () => [],
+		onTrue: () => Array.makeBy(whole, (index) => bytes.subarray(index * computerFileBytes, (index + next) * computerFileBytes))
+	});
+	return [{
+		pending: bytes.subarray(whole * computerFileBytes),
+		sent: sent || whole > nothing
+	}, pieces];
+}, { onHalt: ({ pending, sent }) => Array.filter([pending], (rest) => rest.byteLength > nothing || !sent) });
+/** The computer file's pieces from its start, until one comes back short. */
+const readPieces = (read) => Stream.paginate(nothing, (offset) => Effect.map(read(offset), (piece) => [Array.filter([piece], (bytes) => bytes.byteLength > nothing), Option.liftPredicate(offset + piece.byteLength, () => piece.byteLength === computerFileBytes)]));
+const transfer = Effect.fnUntraced(function* transfer({ client, request }, files) {
 	const computerPath = yield* filePathOf(request.computerPath);
-	if (request.direction === "toComputer") {
-		const content = yield* collect(actor.name, files.download(request.path));
-		yield* client.files(request.computer, ComputerFileRequest.cases.Write.make({
-			content,
-			path: computerPath
-		}));
-		return { bytes: content.byteLength };
-	}
-	const content = yield* client.files(request.computer, ComputerFileRequest.cases.Read.make({ path: computerPath }));
-	const receipt = yield* files.upload(Stream.make(content));
+	if (request.direction === "toComputer") return { bytes: yield* Stream.runFoldEffect(piecesOf(files.download(request.path)), () => nothing, (offset, content) => Effect.as(client.files(request.computer, ComputerFileRequest.cases.WriteAt.make({
+		content,
+		offset,
+		path: computerPath
+	})), offset + content.byteLength)) };
+	const copied = yield* Ref.make(nothing);
+	const pieces = readPieces((offset) => client.files(request.computer, ComputerFileRequest.cases.ReadAt.make({
+		offset,
+		path: computerPath
+	}))).pipe(Stream.tap((piece) => Ref.update(copied, (bytes) => bytes + piece.byteLength)));
+	const receipt = yield* files.upload(pieces);
 	return {
-		bytes: content.byteLength,
+		bytes: yield* Ref.get(copied),
 		receipt
 	};
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akterjs/effect",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "The Effect SDK for Akter: contracts, host runtime, local engine and Story tests.",
   "license": "Apache-2.0",
   "repository": {

package/src/contract/computer/computer-limit.errors.ts

@@ -1,9 +1,9 @@
 import { Schema } from "effect";
 
 /**
- * A new computer would pass a limit, so none was made: `store`, the computers one app environment may keep, or
- * `account`, the sandboxes the platform's provider account may run at once. Remove a computer, or try again once
- * one is gone. Nothing waits for room.
+ * A new computer was refused for capacity, so none was made: `account`, the sandboxes the platform's provider account
+ * may run at once, with the most it holds. Try again once one is free; nothing waits for room. `store`, the computers
+ * one app environment may keep, is no longer set by Akter Cloud or the local engine; older engines may still send it.
  */
 export class ComputerLimitError extends Schema.TaggedError<ComputerLimitError, { readonly brand: unique symbol }>()(
   "ComputerLimitError",

package/src/contract/computer/files/computer-files.schema.ts

@@ -1,11 +1,23 @@
 import { Schema } from "effect";
 
-/** One file per call, bounded before crossing the host/control link. Paths are relative to the computer's files directory. */
+/** The most one call carries across the host/control link. Paths are relative to the computer's files directory. */
 const computerFileBytes = 1_048_576;
 
+const fileStart = 0;
+
+const Offset = Schema.Int.check(Schema.isGreaterThanOrEqualTo(fileStart));
+
+/**
+ * A file of any size moves in pieces: `ReadAt` answers at most `computerFileBytes` from `offset`, fewer at the end of
+ * the file, and `WriteAt` at offset 0 replaces the file, and at a later offset cuts it to that length and appends, so
+ * a resent piece is written once. `Read` and `Write` move a whole file of at most `computerFileBytes` in one call, as
+ * engines before pieces did; they stay so a host and a control plane of different releases still copy small files.
+ */
 const ComputerFileRequest = Schema.TaggedUnion({
   Read: { path: Schema.String },
+  ReadAt: { offset: Offset, path: Schema.String },
   Write: { content: Schema.Uint8ArrayFromBase64, path: Schema.String },
+  WriteAt: { content: Schema.Uint8ArrayFromBase64, offset: Offset, path: Schema.String },
 });
 
 type ComputerFileRequest = typeof ComputerFileRequest.Type;

package/src/host/command/batch/command-batch.sql.ts

@@ -17,7 +17,7 @@ interface Journal {
   readonly known: HashSet.HashSet<string>;
   readonly nextSeq: number;
   readonly recorded: HashMap.HashMap<string, RecordedCommand>;
-  /** The seq each command recorded in this batch was given. */
+  /** The seq of each command the journal answers for and that has one: read at the start, or given in this batch. */
   readonly seqs: HashMap.HashMap<string, number>;
   readonly state: Option.Option<string>;
 }
@@ -36,6 +36,7 @@ interface JournalRead {
   readonly commandId: string;
   readonly exit: string;
   readonly principal: string;
+  readonly seq: number;
 }
 
 const CommandBatch = Context.Reference<Option.Option<Batch>>(
@@ -51,7 +52,7 @@ const nextOf = 1;
 const IdList = Schema.fromJsonString(Schema.Array(Schema.String));
 
 const journalRows = (sql: SqlClient.SqlClient, ids: string): Effect.Effect<readonly JournalRead[], SqlError.SqlError> =>
-  sql<JournalRead>`SELECT command_id AS "commandId", command, exit, principal FROM akter_commands WHERE command_id IN (SELECT value FROM json_each(${ids}))`;
+  sql<JournalRead>`SELECT command_id AS "commandId", command, exit, principal, seq FROM akter_commands WHERE command_id IN (SELECT value FROM json_each(${ids}))`;
 
 const readJournal = Effect.fnUntraced(function* readJournal(sql: SqlClient.SqlClient, commandIds: readonly string[]) {
   const ids = yield* Effect.orDie(Schema.encodeEffect(IdList)(commandIds));
@@ -66,9 +67,9 @@ const readJournal = Effect.fnUntraced(function* readJournal(sql: SqlClient.SqlCl
     known: HashSet.fromIterable(commandIds),
     nextSeq: Option.match(Arr.head(last), { onNone: () => firstSeq, onSome: (row) => row.seq + nextOf }),
     recorded: HashMap.fromIterable(
-      Arr.map(rows, ({ commandId, ...recorded }): [string, RecordedCommand] => [commandId, recorded]),
+      Arr.map(rows, ({ commandId, seq: _seq, ...recorded }): [string, RecordedCommand] => [commandId, recorded]),
     ),
-    seqs: HashMap.empty(),
+    seqs: HashMap.fromIterable(Arr.map(rows, ({ commandId, seq }): [string, number] => [commandId, seq])),
     state: Option.map(Arr.head(states), (row) => row.value),
   } satisfies Journal;
 });
@@ -153,17 +154,23 @@ const CommandBatchJournal = {
     ),
   /** Notes a state the running command saved. */
   saved: (value: string): Effect.Effect<void> => update((journal) => ({ ...journal, state: Option.some(value) })),
-  /** The seq a command recorded in this batch was given, or none when the batch did not record it. */
-  seq: (commandId: string): Effect.Effect<Option.Option<number>> =>
-    Effect.flatMap(CommandBatch, (batch) =>
-      Option.match(batch, {
-        onNone: () => Effect.succeedNone,
-        onSome: (open) =>
-          Effect.map(
-            Ref.get(open.current),
-            Option.flatMap((journal) => HashMap.get(journal.seqs, commandId)),
-          ),
-      }),
+  /**
+   * The seq `commandId` was journaled with, from the batch journal when it answers for the id, so a command's check
+   * whether it already ran costs no round trip of its own.
+   */
+  seq: (
+    sql: SqlClient.SqlClient,
+    commandId: string,
+    read: Effect.Effect<Option.Option<number>, SqlError.SqlError>,
+  ): Effect.Effect<Option.Option<number>, SqlError.SqlError> =>
+    Effect.flatMap(journalOf(sql), (opened) =>
+      Option.match(
+        Option.filter(opened, ([, journal]) => answers(journal, commandId)),
+        {
+          onNone: () => read,
+          onSome: ([, journal]) => Effect.succeed(HashMap.get(journal.seqs, commandId)),
+        },
+      ),
     ),
   /** The actor's current state, from the batch journal when there is one. */
   state: (

package/src/host/computer/local-computer-files.layer.ts

@@ -1,14 +1,15 @@
 import { Array as Arr, Effect, FileSystem, Path, Predicate, Stream, String as Str } from "effect";
 
 import { InvalidRequestError } from "#src/contract/client/invalid-request.errors";
-import { computerFileBytes } from "#src/contract/computer/files/computer-files.schema";
-import type { ComputerFileRequest } from "#src/contract/computer/files/computer-files.schema";
+import { ComputerFileRequest, computerFileBytes } from "#src/contract/computer/files/computer-files.schema";
 import { filePathOf } from "#src/contract/file/file-path.pure";
 import { notHeld, present, recordFor } from "./local-computer-records.layer.js";
 import type { Place } from "./local-computer-records.layer.js";
 
 const extraByte = 1;
 
+const fileStart = 0;
+
 const checkedPath = Effect.fnUntraced(function* checkedPath(disk: string, target: string, actor: string) {
   const fs = yield* FileSystem.FileSystem;
 
@@ -45,6 +46,18 @@ const targetOf = Effect.fnUntraced(function* targetOf(place: Place, relative: st
   );
 });
 
+const joined = (chunks: readonly Uint8Array[]): Uint8Array => {
+  const bytes = new Uint8Array(Arr.reduce(chunks, fileStart, (total, chunk) => total + chunk.byteLength));
+
+  Arr.reduce(chunks, fileStart, (offset, chunk) => {
+    bytes.set(chunk, offset);
+
+    return offset + chunk.byteLength;
+  });
+
+  return bytes;
+};
+
 const readFile = Effect.fnUntraced(function* readFile(target: string, actor: string) {
   const fs = yield* FileSystem.FileSystem;
   const stat = yield* fs.stat(target);
@@ -57,7 +70,7 @@ const readFile = Effect.fnUntraced(function* readFile(target: string, actor: str
   }
 
   const chunks = yield* Stream.runCollect(fs.stream(target, { bytesToRead: computerFileBytes + extraByte }));
-  const content = Uint8Array.from(Arr.flatMap(chunks, (chunk) => [...chunk]));
+  const content = joined(chunks);
 
   if (content.byteLength > computerFileBytes) {
     return yield* InvalidRequestError.make({ actor, message: "a computer file holds at most 1 MiB" });
@@ -66,6 +79,20 @@ const readFile = Effect.fnUntraced(function* readFile(target: string, actor: str
   return content;
 });
 
+/** At most one call's bytes from `offset`; fewer at the end of the file. */
+const readPiece = Effect.fnUntraced(function* readPiece(target: string, offset: number, actor: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const stat = yield* fs.stat(target);
+
+  if (stat.type !== "File") {
+    return yield* InvalidRequestError.make({ actor, message: "a computer file must be a regular file" });
+  }
+
+  const chunks = yield* Stream.runCollect(fs.stream(target, { bytesToRead: computerFileBytes, offset }));
+
+  return joined(chunks);
+});
+
 const writeFile = Effect.fnUntraced(function* writeFile(target: string, content: Uint8Array) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
@@ -77,6 +104,28 @@ const writeFile = Effect.fnUntraced(function* writeFile(target: string, content:
   return new Uint8Array();
 }, Effect.scoped);
 
+/** At offset 0 the piece replaces the file; later, the file is cut to `offset` and the piece appended. */
+const writePiece = Effect.fnUntraced(function* writePiece(
+  target: string,
+  { actor, content, offset }: { readonly actor: string; readonly content: Uint8Array; readonly offset: number },
+) {
+  if (offset === fileStart) {
+    return yield* writeFile(target, content);
+  }
+
+  const fs = yield* FileSystem.FileSystem;
+  const stat = yield* fs.stat(target);
+
+  if (stat.size < BigInt(offset)) {
+    return yield* InvalidRequestError.make({ actor, message: "a piece must follow the bytes already written" });
+  }
+
+  yield* fs.truncate(target, offset);
+  yield* fs.writeFile(target, content, { flag: "a" });
+
+  return new Uint8Array();
+});
+
 const localComputerFile = Effect.fnUntraced(function* localComputerFile(place: Place, request: ComputerFileRequest) {
   const record = yield* recordFor(place);
 
@@ -87,17 +136,23 @@ const localComputerFile = Effect.fnUntraced(function* localComputerFile(place: P
     InvalidRequestError.make({ actor: place.actor, message: failure.message }),
   );
 
-  if (Predicate.isTagged(request, "Write") && request.content.byteLength > computerFileBytes) {
-    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"));
+  const writing = Predicate.isTagged(request, "Write") || Predicate.isTagged(request, "WriteAt");
 
-  if (Predicate.isTagged(request, "Write")) {
-    return yield* writeFile(target, request.content);
+  if (writing && request.content.byteLength > computerFileBytes) {
+    return yield* InvalidRequestError.make({
+      actor: place.actor,
+      message: "a computer file call carries at most 1 MiB",
+    });
   }
 
-  return yield* readFile(target, place.actor);
+  const target = yield* targetOf(place, relative, writing);
+
+  return yield* ComputerFileRequest.match(request, {
+    Read: () => readFile(target, place.actor),
+    ReadAt: ({ offset }) => readPiece(target, offset, place.actor),
+    Write: ({ content }) => writeFile(target, content),
+    WriteAt: ({ content, offset }) => writePiece(target, { actor: place.actor, content, offset }),
+  });
 });
 
 export { localComputerFile };

package/src/host/computer/local-computer-records.layer.ts

@@ -1,18 +1,14 @@
-import { Array as Arr, Effect, FileSystem, Option, Schema, String as Str } from "effect";
-import type { Path, Semaphore } from "effect";
+import { Effect, FileSystem, Option, Schema, String as Str } from "effect";
+import type { Path } from "effect";
 
 import type { ComputerAddress, ComputerClientFailure } from "#src/contract/computer/computer-client.contract";
 import { ComputerHeldError } from "#src/contract/computer/computer-held.errors";
-import { ComputerLimitError } from "#src/contract/computer/computer-limit.errors";
 import { ComputerLostError } from "#src/contract/computer/computer-lost.errors";
 import { ComputerNotFoundError } from "#src/contract/computer/computer-not-found.errors";
 import type { Computer, ComputerState } from "#src/contract/computer/computer.schema";
 import { RecordJson } from "./local-computer.schema.js";
 import type { LocalComputerRecord, LocalState } from "./local-computer.schema.js";
 
-/** 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;
@@ -30,8 +26,6 @@ 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;
 }
@@ -153,53 +147,6 @@ const movedTo = Effect.fnUntraced(function* movedTo(place: Place, record: LocalC
   return yield* saveRecord(place, { ...record, state });
 });
 
-/** Every computer the store keeps, of every actor. */
-const keptIn = Effect.fnUntraced(function* keptIn({ path, root }: Store) {
-  const fs = yield* FileSystem.FileSystem;
-
-  const under = (directory: string): Effect.Effect<readonly string[], DiskError, FileSystem.FileSystem> =>
-    Effect.map(
-      listed(directory),
-      Arr.map((entry) => path.join(directory, entry)),
-    );
-
-  const actors = yield* under(root);
-  const keys = yield* Effect.forEach(actors, under);
-  const computers = yield* Effect.forEach(Arr.flatten(keys), under);
-
-  return yield* Effect.filter(Arr.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 }: { readonly computer: string; readonly store: Store }) =>
-  <Value, Services>(
-    making: Effect.Effect<Value, Failing, Services>,
-  ): Effect.Effect<Value, Failing, Services | FileSystem.FileSystem> =>
-    store.admission.withPermit(
-      Effect.gen(function* admitComputer() {
-        const computers = yield* keptIn(store);
-
-        if (computers.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,
-};
+export { computerOf, findRecord, keySegment, listed, movedTo, notHeld, placeOf, present, recordFor, saveRecord };
 
 export type { DiskError, Failing, Place, Recorded, Store };

package/src/host/computer/local-computers.adapter.ts

@@ -26,7 +26,6 @@ import type { Computer, ComputerSpec, ExecRequest, ExecResult } from "#src/contr
 import { localLog } from "./local-computer-log.layer.js";
 import type { LocalLog } from "./local-computer-log.layer.js";
 import {
-  admitted,
   computerOf,
   findRecord,
   keySegment,
@@ -91,7 +90,7 @@ const made = Effect.fnUntraced(function* made(local: Local, place: Place, spec:
 const ensureIn = (local: Local, place: Place, spec: ComputerSpec): Answer<Computer> =>
   Effect.flatMap(findRecord(place), (found) =>
     Option.match(found, {
-      onNone: () => admitted({ computer: spec.name, store: local })(made(local, place, spec)),
+      onNone: () => made(local, place, spec),
       onSome: (record) =>
         Effect.gen(function* ensureExisting() {
           yield* notHeld(record);
@@ -255,7 +254,7 @@ const forkIn = (local: Local, place: Place, fork: ComputerFork): Answer<Computer
 
     yield* present(place);
 
-    const forked = yield* admitted({ computer: name, store: local })(copied(place, target, { ...record.spec, name }));
+    const forked = yield* copied(place, target, { ...record.spec, name });
 
     yield* local.log.note(place, "info", `forked into ${fork.into.actor}/${fork.into.key}${heldNote(fork.name, "as")}`);
 
@@ -338,10 +337,8 @@ const clientFor =
  */
 const localAt = Effect.fnUntraced(function* localAt(root: string) {
   const path = yield* Path.Path;
-  const admission = yield* Semaphore.make(onePermit);
 
   return {
-    admission,
     locks: MutableHashMap.empty<string, Semaphore.Semaphore>(),
     log: localLog(path),
     path,

package/src/host/fork/fork-computers.adapter.ts

@@ -1,23 +1,11 @@
-import {
-  Array as Arr,
-  Clock,
-  Context,
-  Effect,
-  FileSystem,
-  Layer,
-  Match,
-  Option,
-  Path,
-  Semaphore,
-  String as Str,
-} from "effect";
+import { Array as Arr, Clock, Context, Effect, FileSystem, Layer, Match, Option, Path, String as Str } from "effect";
 
 import { ActorUnavailableError } from "#src/contract/client/actor-unavailable.errors";
-import { InvalidRequestError } from "#src/contract/client/invalid-request.errors";
+import type { InvalidRequestError } from "#src/contract/client/invalid-request.errors";
 import { ActorComputerClients } from "#src/contract/computer/computer-client.adapter";
 import type { ComputerAddress, ComputerClient } from "#src/contract/computer/computer-client.contract";
 import { localLog } from "#src/host/computer/local-computer-log.layer";
-import { admitted, findRecord, listed, placeOf, saveRecord } from "#src/host/computer/local-computer-records.layer";
+import { findRecord, listed, placeOf, saveRecord } from "#src/host/computer/local-computer-records.layer";
 import type { Failing, Place, Store } from "#src/host/computer/local-computer-records.layer";
 
 /** One actor fork's computers: the parent's, copied into the child, under the store's computers directory. */
@@ -48,15 +36,12 @@ interface Found {
 
 const markPrefix = "@fork-";
 
-const oneAtATime = 1;
-
 // A computer's name starts with a letter and a key segment never holds "@", so a mark is never read as either.
 const markOf = (fork: string): string => `${markPrefix}${encodeURIComponent(fork)}`;
 
 const storeOf = Effect.fnUntraced(function* storeOf(root: string) {
   const path = yield* Path.Path;
-  const admission = yield* Semaphore.make(oneAtATime);
-  const store: Store = { admission, path, root };
+  const store: Store = { path, root };
 
   return store;
 });
@@ -72,11 +57,6 @@ const failedWith =
             actor,
             message: `${actor} can't fork while its computer ${computer} is held by ${hold}, a fork that didn't finish. Retry that fork, or resume the computer with the hold ${hold}, to release it.`,
           }),
-        ComputerLimitError: ({ maximum }) =>
-          InvalidRequestError.make({
-            actor,
-            message: `${actor} can't fork: copying its computers would pass the store's limit of ${String(maximum)} computers. Remove a computer, then fork again.`,
-          }),
         InvalidRequestError: (invalid): ForkFailure => invalid,
       }),
       Match.orElse(() =>
@@ -174,10 +154,7 @@ const copied =
     const target = placeOf(store)(child, name);
     const note = `copied from ${parent.actor}/${parent.key} by the fork ${fork}, stopped`;
 
-    return Effect.andThen(
-      admitted({ computer: name, store })(copyOne(source, target)),
-      localLog(store.path).note(target, "info", note),
-    );
+    return Effect.andThen(copyOne(source, target), localLog(store.path).note(target, "info", note));
   };
 
 const alreadyKept = ({ child, parent }: ComputersFork): ActorUnavailableError =>

package/src/serve/live/live-tables.sql.ts

@@ -119,11 +119,9 @@ const recordedVersion = ({ commandId, reader }: CommandAt): Sql<Option.Option<nu
     Option.map(Arr.head(rows), (row) => row.seq),
   );
 
-/** A command recorded in the running engine batch has its seq in the batch journal; any other is read. */
+/** A command the running engine batch's journal answers for has its seq there; any other is read. */
 const commandVersion = (at: CommandAt): Sql<Option.Option<number>> =>
-  Effect.flatMap(CommandBatchJournal.seq(at.commandId), (seq) =>
-    Option.match(seq, { onNone: () => recordedVersion(at), onSome: () => Effect.succeed(seq) }),
-  );
+  CommandBatchJournal.seq(at.reader, at.commandId, recordedVersion(at));
 
 /**
  * When a command recorded in the journal ran, in epoch milliseconds. One the running engine batch recorded, which is

package/src/serve/rpc/computer/computer-copy.layer.ts

@@ -1,4 +1,4 @@
-import { Boolean as Bool, Effect, Predicate, Stream } from "effect";
+import { Array as Arr, Boolean as Bool, Effect, Option, Predicate, Ref, Stream } from "effect";
 
 import { CurrentCaller } from "#src/contract/caller/current-caller.service";
 import { InvalidRequestError } from "#src/contract/client/invalid-request.errors";
@@ -13,25 +13,60 @@ import type { FileActor } from "#src/serve/rpc/file/file-rpc-access.pure";
 
 const invalid = (actor: string, message: string): InvalidRequestError => InvalidRequestError.make({ actor, message });
 
-const collect = <Failure, Services>(
-  actor: string,
-  source: Stream.Stream<Uint8Array, Failure, Services>,
-): Effect.Effect<Uint8Array, Failure | InvalidRequestError, Services> =>
-  Stream.runFoldEffect(
-    source,
-    () => new Uint8Array(),
-    (before, chunk) => {
-      if (before.byteLength + chunk.byteLength > computerFileBytes) {
-        return Effect.fail(invalid(actor, "a computer file holds at most 1 MiB"));
-      }
+const nothing = 0;
+
+const next = 1;
+
+interface Piecing {
+  /** Bytes read but not yet a whole piece. */
+  readonly pending: Uint8Array;
+  readonly sent: boolean;
+}
+
+const concatenated = (before: Uint8Array, after: Uint8Array): Uint8Array => {
+  const joined = new Uint8Array(before.byteLength + after.byteLength);
 
-      const joined = new Uint8Array(before.byteLength + chunk.byteLength);
+  joined.set(before);
+  joined.set(after, before.byteLength);
 
-      joined.set(before);
-      joined.set(chunk, before.byteLength);
+  return joined;
+};
 
-      return Effect.succeed(joined);
+/**
+ * The file's bytes as the pieces one call carries: whole pieces of `computerFileBytes`, then what is left, and one
+ * empty piece for an empty file, so writing it still makes the file.
+ */
+const piecesOf = <Failure, Services>(
+  source: Stream.Stream<Uint8Array, Failure, Services>,
+): Stream.Stream<Uint8Array, Failure, Services> =>
+  Stream.mapAccum(
+    source,
+    (): Piecing => ({ pending: new Uint8Array(), sent: false }),
+    ({ pending, sent }, chunk) => {
+      const bytes = concatenated(pending, chunk);
+      const whole = Math.floor(bytes.byteLength / computerFileBytes);
+
+      // `Arr.makeBy` makes at least one element, so no whole piece is no pieces.
+      const pieces = Bool.match(whole > nothing, {
+        onFalse: () => [],
+        onTrue: () =>
+          Arr.makeBy(whole, (index) => bytes.subarray(index * computerFileBytes, (index + next) * computerFileBytes)),
+      });
+
+      return [{ pending: bytes.subarray(whole * computerFileBytes), sent: sent || whole > nothing }, pieces];
     },
+    { onHalt: ({ pending, sent }) => Arr.filter([pending], (rest) => rest.byteLength > nothing || !sent) },
+  );
+
+/** The computer file's pieces from its start, until one comes back short. */
+const readPieces = (
+  read: (offset: number) => Effect.Effect<Uint8Array, ComputerClientFailure>,
+): Stream.Stream<Uint8Array, ComputerClientFailure> =>
+  Stream.paginate(nothing, (offset) =>
+    Effect.map(read(offset), (piece) => [
+      Arr.filter([piece], (bytes) => bytes.byteLength > nothing),
+      Option.liftPredicate(offset + piece.byteLength, () => piece.byteLength === computerFileBytes),
+    ]),
   );
 
 interface Copying {
@@ -42,23 +77,37 @@ interface Copying {
 }
 
 const transfer = Effect.fnUntraced(function* transfer(
-  { actor, client, request }: Copying,
+  { client, request }: Copying,
   files: ReturnType<typeof hostFileClient>,
 ) {
   const computerPath = yield* filePathOf(request.computerPath);
 
   if (request.direction === "toComputer") {
-    const content = yield* collect(actor.name, files.download(request.path));
+    const bytes = yield* Stream.runFoldEffect(
+      piecesOf(files.download(request.path)),
+      () => nothing,
+      (offset, content) =>
+        Effect.as(
+          client.files(
+            request.computer,
+            ComputerFileRequest.cases.WriteAt.make({ content, offset, path: computerPath }),
+          ),
+          offset + content.byteLength,
+        ),
+    );
+
+    return { bytes } satisfies ComputerCopyResult;
+  }
 
-    yield* client.files(request.computer, ComputerFileRequest.cases.Write.make({ content, path: computerPath }));
+  const copied = yield* Ref.make(nothing);
 
-    return { bytes: content.byteLength } satisfies ComputerCopyResult;
-  }
+  const pieces = readPieces((offset) =>
+    client.files(request.computer, ComputerFileRequest.cases.ReadAt.make({ offset, path: computerPath })),
+  ).pipe(Stream.tap((piece) => Ref.update(copied, (bytes) => bytes + piece.byteLength)));
 
-  const content = yield* client.files(request.computer, ComputerFileRequest.cases.Read.make({ path: computerPath }));
-  const receipt = yield* files.upload(Stream.make(content));
+  const receipt = yield* files.upload(pieces);
 
-  return { bytes: content.byteLength, receipt } satisfies ComputerCopyResult;
+  return { bytes: yield* Ref.get(copied), receipt } satisfies ComputerCopyResult;
 });
 
 /** Both directions pass the actor's file authorization rule; a copy never bypasses a command to attach a file. */