@graftland/plugin-remote 0.0.0-stage → 0.3.0

package/dist/supervisorPlugin-Inb1S5IV.js

@@ -0,0 +1,737 @@
+import { a as provide, l as make$2, o as fork, u as optional } from "./Graft-BsYq3F-J.js";
+import { a as PositiveDuration, i as Supervisor$1, t as resolve } from "./Packages-B1TPk8pa.js";
+import { t as ConfigDirectory } from "./ConfigDirectory-BCC6q2R4.js";
+import { C as negotiate, E as make$3, S as keyOf, T as stoppingRecord, _ as StateStorageError, a as ExecutionError, d as SessionAccessDenied, f as SessionConflict, g as StateDirectoryLocked, h as StaleSession, i as Execution, m as SessionStopped, n as Session$1, o as Key, p as SessionRecord, r as channel, s as LeaseExpired, t as Peer, u as RunnerClosing, v as Store, w as stoppedRecord, x as childOf, y as TerminationUnconfirmed } from "./Peer-IJgFK6mD.js";
+import { t as observe } from "./ProcessObservation-DEGrEMfP.js";
+import { t as make$4 } from "./FailureGroup-BcH0XOBi.js";
+import { t as CommandJson } from "./WatchdogProtocol-BZmVxrBP.js";
+import { c as TransportError } from "./Errors-oPsTLY7l.js";
+import { t as Bootstrap } from "./Bootstrap-MCwivGN1.js";
+import { t as command } from "./command-9zrHdbwT.js";
+import { n as close } from "./release-BY4Mlluy.js";
+import { n as cleanupCause } from "./cleanup-BPWr-5U9.js";
+import { n as make$5, o as defaults } from "./port-Blbh8tms.js";
+import { i as resources, t as ServeLifecycle } from "./ServeLifecycle-CJM0gG5B.js";
+import { Array, Cause, Clock, Context, Data, Deferred, Duration, Effect, Equal, Exit, FiberHandle, FiberSet, FileSystem, HashMap, HashSet, Layer, Option, Path, Queue, RcMap, Ref, Result, Schedule, Schema, Scope, Semaphore, Sink, Stream, String, SynchronizedRef } from "effect";
+import process from "node:process";
+import { Digest, SecureRandom } from "effect/crypto";
+import { RpcServer } from "effect/rpc";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+// packages/remote/src/internal/runner/Lock.ts
+/** SQLite owns the local directory lock for the enclosing scope, including failed startup. */
+const acquire = (directory) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.uninterruptible);
+	const { DatabaseSync } = yield* Effect.promise(() => import("node:sqlite")).pipe(Effect.uninterruptible);
+	const locked = (cause) => StateDirectoryLocked.make({
+		detail: "The runner state directory is already owned or cannot be locked",
+		cause: Cause.die(cause)
+	});
+	const db = yield* Effect.acquireRelease(Effect.try({
+		try: () => new DatabaseSync(path.join(directory, "owner.sqlite")),
+		catch: locked
+	}), (db) => Effect.sync(() => db.close()));
+	yield* Effect.try({
+		try: () => db.exec("BEGIN EXCLUSIVE"),
+		catch: locked
+	});
+});
+// packages/remote/src/internal/runner/Retention.ts
+/** A terminal high-water record fences every older Open, even after its request id is forgotten. */
+const retain = (records) => {
+	const highWater = Array.reduce(records, HashMap.empty(), (water, record) => HashMap.set(water, keyOf(record.handle.key), Math.max(Option.getOrElse(HashMap.get(water, keyOf(record.handle.key)), () => 0), record.handle.generation)));
+	return Array.filter(records, (record) => record.phase !== "Stopped" || record.handle.generation === Option.getOrUndefined(HashMap.get(highWater, keyOf(record.handle.key))));
+};
+/** Apply the same retention rule to both in-memory stores. */
+const save = (records, record) => HashMap.fromIterable(Array.map(retain(Array.fromIterable(HashMap.values(HashMap.set(records, record.handle.token, record)))), (record) => [record.handle.token, record]));
+// packages/remote/src/internal/runner/Store.ts
+/** Injectable store used by deterministic supervisor tests. */
+const memory = Effect.gen(function* () {
+	const records = yield* Ref.make(HashMap.empty());
+	return Store.of({
+		list: Ref.get(records).pipe(Effect.map((records) => Array.fromIterable(HashMap.values(records)))),
+		save: (record) => Ref.update(records, (all) => save(all, record))
+	});
+});
+/**
+* Atomically replaced records retain unfinished sessions and each key's high-water mark.
+* Older terminal request ids expire; Open fences their retries with expectedGeneration.
+* Requires exclusive directory ownership; it is not a multi-writer database.
+*/
+const directory = (root) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const digest = yield* Digest.Digest;
+	const json = Schema.fromJsonString(Schema.toCodecJson(SessionRecord));
+	const random = yield* SecureRandom.SecureRandom;
+	const storage = (effect) => effect.pipe(Effect.mapError((error) => error._tag === "StateStorageError" ? error : StateStorageError.make({
+		detail: "Runner state storage failed",
+		cause: Cause.fail(error)
+	})));
+	yield* storage(fs.makeDirectory(root, { recursive: true }).pipe(Effect.uninterruptible));
+	const mutex = yield* Semaphore.make(1);
+	const read = Effect.gen(function* () {
+		const files = yield* fs.readDirectory(root);
+		return yield* Effect.forEach(Array.filter(files, String.endsWith(".json")), (file) => fs.readFileString(path.join(root, file)).pipe(Effect.flatMap(Schema.decodeEffect(json)), Effect.map((record) => ({
+			file,
+			record
+		}))));
+	});
+	const compact = Effect.scoped(Effect.gen(function* () {
+		const rows = yield* read;
+		const retained = retain(Array.map(rows, (row) => row.record));
+		const tokens = HashSet.fromIterable(Array.map(retained, (record) => record.handle.token));
+		const obsolete = Array.filter(rows, (row) => !HashSet.has(tokens, row.record.handle.token));
+		yield* Effect.forEach(obsolete, (row) => fs.remove(path.join(root, row.file)).pipe(Effect.uninterruptible), { discard: true });
+		if (obsolete.length > 0) yield* (yield* fs.open(root, { flag: "r" })).sync.pipe(Effect.uninterruptible);
+	}));
+	yield* storage(compact);
+	return Store.of({
+		list: storage(mutex.withPermit(read.pipe(Effect.map((rows) => Array.map(rows, (row) => row.record))))),
+		save: (record) => storage(mutex.withPermit(Effect.scoped(Effect.gen(function* () {
+			const encoded = yield* Schema.encodeEffect(json)(record);
+			const address = yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Struct({
+				key: Key,
+				generation: Schema.Int
+			})))({
+				key: record.handle.key,
+				generation: record.handle.generation
+			});
+			const name = yield* digest.digestHex(Digest.sha256, new TextEncoder().encode(address));
+			const nonce = yield* random.uuidV4();
+			const temporary = path.join(root, `.${name}.${nonce}.tmp`);
+			const destination = path.join(root, name + ".json");
+			yield* Effect.acquireRelease(fs.open(temporary, {
+				flag: "wx",
+				mode: 384
+			}), () => fs.remove(temporary, { force: true }).pipe(Effect.orDie)).pipe(Effect.flatMap((file) => file.writeAll(new TextEncoder().encode(encoded)).pipe(Effect.uninterruptible, Effect.andThen(file.sync.pipe(Effect.uninterruptible)))));
+			yield* Effect.uninterruptible(Effect.gen(function* () {
+				yield* fs.rename(temporary, destination);
+				yield* (yield* fs.open(root, { flag: "r" })).sync.pipe(Effect.uninterruptible);
+			}));
+			yield* compact;
+		}))))
+	});
+});
+Layer.effect(Store, memory);
+const layerDirectory = (root) => Layer.effect(Store, directory(root));
+// packages/remote/src/internal/runner/Processes.ts
+const inspect = (pid) => Effect.scoped(Effect.gen(function* () {
+	const child = yield* (yield* ChildProcessSpawner.ChildProcessSpawner).spawn(ChildProcess.make("ps", [
+		"-p",
+		`${pid}`,
+		"-o",
+		"lstart=",
+		"-o",
+		"stat="
+	], {
+		env: {
+			...process.env,
+			LC_ALL: "C"
+		},
+		stdin: "ignore"
+	}));
+	const [code, output, stderr] = yield* Effect.all([
+		child.exitCode,
+		child.stdout.pipe(Stream.decodeText(), Stream.mkString),
+		child.stderr.pipe(Stream.decodeText(), Stream.mkString)
+	], { concurrency: "unbounded" });
+	if (code === 1 && String.trim(output) === "") return Option.none();
+	const [, born, status] = /^(.{24})\s+(\S+)$/m.exec(String.trim(output)) ?? [];
+	if (code !== 0 || born === void 0 || status === void 0) return yield* ExecutionError.make({ detail: "Cannot inspect process identity: " + stderr });
+	if (String.startsWith("Z")(status)) return Option.none();
+	return Option.some({ born });
+})).pipe(Effect.mapError((error) => error._tag === "ExecutionError" ? error : ExecutionError.make({
+	detail: "Inspecting process identity failed",
+	cause: Cause.fail(error)
+})));
+const identity = (pid) => Effect.gen(function* () {
+	const current = yield* inspect(pid);
+	if (Option.isNone(current)) return yield* ExecutionError.make({ detail: "The child exited before its identity could be recorded" });
+	return {
+		pid,
+		start: current.value
+	};
+});
+const matches = (child) => Effect.gen(function* () {
+	const current = yield* inspect(child.pid);
+	if (Option.isNone(current) || current.value.born !== child.start.born) return false;
+	return true;
+});
+const recover$1 = (child) => Effect.gen(function* () {
+	if (!(yield* matches(child))) return {
+		kind: "Exited",
+		exit: {
+			code: null,
+			signal: null
+		},
+		cause: Cause.empty
+	};
+	const sent = yield* Effect.exit(Effect.try({
+		try: () => process.kill(child.pid, "SIGKILL"),
+		catch: (cause) => ExecutionError.make({
+			detail: "Signaling the orphan failed",
+			cause: Cause.die(cause)
+		})
+	}));
+	const confirmed = yield* matches(child).pipe(Effect.repeat({
+		schedule: Schedule.spaced("50 millis"),
+		while: (value) => value
+	}), Effect.timeoutOption("10 seconds"));
+	if (Option.isNone(confirmed)) return yield* TerminationUnconfirmed.make({
+		detail: "The orphan did not exit after recovery",
+		cause: sent._tag === "Failure" ? sent.cause : Cause.empty
+	});
+	return {
+		kind: "Killed",
+		exit: {
+			code: null,
+			signal: "SIGKILL"
+		},
+		cause: sent._tag === "Failure" ? sent.cause : Cause.empty
+	};
+});
+// packages/remote/src/internal/runner/Execution.ts
+var Channels = class extends Context.Service()("@graftland/plugin-remote/internal/runner/Execution/Channels") {};
+const make$1 = (root) => Effect.gen(function* () {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const platform = Context.make(ChildProcessSpawner.ChildProcessSpawner, spawner).pipe(Context.add(FileSystem.FileSystem, fs), Context.add(Path.Path, path));
+	const peers = yield* Ref.make(HashMap.empty());
+	const claimed = yield* Ref.make(HashSet.empty());
+	return {
+		driver: Execution.of({
+			recover: (child) => recover$1(child).pipe(Effect.provideContext(platform)),
+			spawn: (handle, request, limits) => Effect.gen(function* () {
+				const resolved = yield* resolve(root, request.specifier, request.digest);
+				const argv = yield* command();
+				const child = yield* spawner.spawn(ChildProcess.make(argv[0], [
+					...Array.drop(argv, 1),
+					"child",
+					resolved.entry,
+					handle.token,
+					yield* Schema.encodeEffect(Schema.fromJsonString(Bootstrap))({
+						identity: {
+							id: handle.key.instance,
+							generation: handle.generation
+						},
+						limits
+					})
+				], {
+					stdin: "pipe",
+					stdout: "pipe",
+					stderr: "pipe",
+					additionalFds: {
+						fd3: { type: "output" },
+						fd4: { type: "input" }
+					},
+					forceKillAfter: "1 second"
+				}));
+				const observation = yield* observe(child);
+				const exited = observation.exited.pipe(Effect.mapError((error) => ExecutionError.make({
+					detail: "Observing child exit failed",
+					cause: Cause.fail(error)
+				})));
+				const failures = yield* make$4();
+				yield* failures.run(observation.failure.pipe(Effect.mapError((error) => ExecutionError.make({
+					detail: "Reading child output failed",
+					cause: Cause.fail(error)
+				}))));
+				const controls = yield* Queue.bounded(4);
+				yield* failures.run(Stream.fromQueue(controls).pipe(Stream.map((line) => new TextEncoder().encode(line + "\n")), Stream.run(child.getInputFd(4)), Effect.mapError((error) => ExecutionError.make({
+					detail: "Child supervision channel failed",
+					cause: Cause.fail(error)
+				}))));
+				const send = (value) => Effect.raceFirst(Schema.encodeEffect(CommandJson)(value).pipe(Effect.flatMap((line) => Queue.offer(controls, line)), Effect.asVoid, Effect.mapError((error) => ExecutionError.make({
+					detail: "Encoding watchdog command failed",
+					cause: Cause.fail(error)
+				}))), failures.await);
+				const peer = yield* make$3({
+					input: child.getOutputFd(3).pipe(Stream.mapError((error) => TransportError.make({ cause: Cause.fail(error) }))),
+					output: child.stdin.pipe(Sink.mapError((error) => TransportError.make({ cause: Cause.fail(error) })))
+				});
+				const identity$1 = yield* identity(child.pid);
+				yield* Ref.update(peers, HashMap.set(handle.token, peer));
+				yield* Effect.addFinalizer(() => Ref.update(peers, HashMap.remove(handle.token)));
+				return {
+					code: resolved.identity,
+					start: send({ kind: "start" }),
+					identity: identity$1,
+					exited,
+					interrupt: send({ kind: "stop" }),
+					kill: child.kill({ killSignal: "SIGKILL" }).pipe(Effect.mapError((error) => ExecutionError.make({
+						detail: "Killing the child failed",
+						cause: Cause.fail(error)
+					}))),
+					renew: (millis) => send({
+						kind: "renew",
+						millis
+					})
+				};
+			}).pipe(Effect.provideContext(platform), Effect.catchTags({
+				PlatformError: (error) => Effect.fail(ExecutionError.make({
+					detail: "Starting the child failed",
+					cause: Cause.fail(error)
+				})),
+				SchemaError: (error) => Effect.fail(ExecutionError.make({
+					detail: "Encoding child bootstrap failed",
+					cause: Cause.fail(error)
+				}))
+			}))
+		}),
+		peer: (token) => Effect.acquireRelease(Effect.gen(function* () {
+			const peer = yield* Ref.get(peers).pipe(Effect.flatMap((all) => {
+				const peer = HashMap.get(all, token);
+				return peer._tag === "Some" ? Effect.succeed(peer.value) : Effect.fail(SessionStopped.make({ detail: "The execution channel is no longer available" }));
+			}));
+			if (yield* Ref.modify(claimed, (all) => [HashSet.has(all, token), HashSet.add(all, token)])) return yield* SessionConflict.make({ detail: "The instance channel is already attached" });
+			return peer;
+		}), () => Ref.update(claimed, HashSet.remove(token)))
+	};
+});
+const layer$1 = (root) => Layer.effectContext(make$1(root).pipe(Effect.map((execution) => Context.make(Execution, execution.driver).pipe(Context.add(Channels, { peer: execution.peer })))));
+// packages/remote/src/internal/runner/Supervisor.ts
+var Supervisor = class extends Context.Service()("@graftland/plugin-remote/internal/runner/Supervisor") {};
+const Launch = Data.taggedEnum();
+const ExecutionState = Data.taggedEnum();
+const Session = Data.taggedEnum();
+function snapshot(state) {
+	return state._tag === "Loading" ? {
+		...state.record,
+		phase: "Loading",
+		load: state.request,
+		launch: state.launch._tag === "Starting" ? { _tag: "Starting" } : {
+			_tag: "Registered",
+			child: state.launch.unit.identity
+		}
+	} : state.record;
+}
+const live = (state, now) => {
+	if (state._tag === "Stopping" || state._tag === "Stopped") return Result.fail(state.record.reason._tag === "Expired" ? LeaseExpired.make({ detail: "The session lease has expired" }) : SessionStopped.make({ detail: "The session is stopping or stopped" }));
+	return now >= state.deadline ? Result.fail(LeaseExpired.make({ detail: "The session lease has expired" })) : Result.succeed(state);
+};
+const executionOf = (state) => {
+	switch (state._tag) {
+		case "Open": return ExecutionState.Absent();
+		case "Loading": return state.launch._tag === "Registered" ? ExecutionState.Running({ unit: state.launch.unit }) : ExecutionState.Absent();
+		case "Loaded": return ExecutionState.Running({ unit: state.unit });
+	}
+};
+/** All state transitions are pure; the caller serializes persistence and publication. */
+const beginLoad = (state, request, reply) => Session.Loading({
+	record: state.record,
+	deadline: state.deadline,
+	request,
+	reply,
+	launch: Launch.Starting()
+});
+const registerUnit = (state, unit) => {
+	if (state._tag !== "Loading") return Result.fail(SessionStopped.make({ detail: "The session is stopping or stopped" }));
+	if (state.launch._tag === "Registered") return Result.fail(ExecutionError.make({ detail: "An execution adapter registered more than one child" }));
+	return Result.succeed(Session.Loading({
+		...state,
+		launch: Launch.Registered({ unit })
+	}));
+};
+const loaded = (state, code) => {
+	if (state._tag !== "Loading") return Result.fail(SessionStopped.make({ detail: "The session is stopping or stopped" }));
+	if (state.launch._tag !== "Registered") return Result.fail(ExecutionError.make({ detail: "Execution adapter returned without registering its child" }));
+	return Result.succeed(Session.Loaded({
+		deadline: state.deadline,
+		unit: state.launch.unit,
+		record: {
+			...state.record,
+			phase: "Loaded",
+			load: state.request,
+			code,
+			child: state.launch.unit.identity
+		}
+	}));
+};
+const beginStop = (state, reason, reply, exit) => Session.Stopping({
+	record: stoppingRecord(snapshot(state), reason),
+	reply,
+	execution: Option.match(exit, {
+		onNone: () => executionOf(state),
+		onSome: (exit) => ExecutionState.Exited({ exit })
+	})
+});
+const nanos = (millis) => BigInt(Math.ceil(millis * 1e6));
+const emptyTermination = {
+	kind: "Exited",
+	exit: {
+		code: 0,
+		signal: null
+	},
+	cause: Cause.empty
+};
+const exitCause = (exit) => Exit.isFailure(exit) ? exit.cause : Cause.empty;
+/** A signal is a request; only the exited effect confirms that the execution has stopped. */
+const terminate = (execution, grace, confirmation) => {
+	if (execution._tag === "Absent") return Effect.succeed(emptyTermination);
+	if (execution._tag === "Exited") return Effect.succeed({
+		...emptyTermination,
+		exit: execution.exit
+	});
+	const child = execution.unit;
+	return Effect.gen(function* () {
+		const graceful = yield* child.interrupt.pipe(Effect.andThen(child.exited), Effect.timeoutOption(grace), Effect.exit);
+		if (Exit.isSuccess(graceful) && Option.isSome(graceful.value)) return {
+			...emptyTermination,
+			exit: graceful.value.value
+		};
+		const killed = yield* Effect.exit(child.kill);
+		const forced = yield* child.exited.pipe(Effect.timeoutOption(confirmation), Effect.exit);
+		const cause = Cause.combine(Cause.combine(exitCause(graceful), exitCause(killed)), exitCause(forced));
+		if (Exit.isFailure(forced) || Option.isNone(forced.value)) return yield* TerminationUnconfirmed.make({
+			detail: "The child exit could not be confirmed",
+			cause
+		});
+		return {
+			kind: "Killed",
+			exit: forced.value.value,
+			cause
+		};
+	});
+};
+const initialize = (options = {}) => Effect.gen(function* () {
+	const store = yield* Store;
+	const execution = yield* Execution;
+	const random = yield* SecureRandom.SecureRandom;
+	const parent = yield* Effect.scope;
+	const owner = yield* Scope.fork(parent);
+	return {
+		store,
+		execution,
+		random,
+		owner,
+		workers: yield* FiberSet.make().pipe(Scope.provide(owner)),
+		locks: yield* RcMap.make({ lookup: (_key) => Semaphore.make(1) }).pipe(Scope.provide(owner)),
+		lease: Duration.toMillis(options.lease ?? "15 seconds"),
+		grace: Duration.toMillis(options.grace ?? "5 seconds"),
+		confirmation: Duration.toMillis(options.confirmationTimeout ?? "5 seconds"),
+		limits: options.limits ?? defaults,
+		records: yield* Ref.make(HashMap.empty()),
+		entries: yield* Ref.make(HashMap.empty()),
+		health: yield* make$4().pipe(Scope.provide(owner)),
+		closing: yield* Ref.make(false)
+	};
+});
+const operations = (runtime) => {
+	const { store, execution, workers, grace, confirmation, records, entries, health, closing } = runtime;
+	const poison = health.failCause;
+	const observe = (effect) => effect.pipe(Effect.asVoid, Effect.catchCause(poison));
+	const healthy = health.check.pipe(Effect.andThen(Effect.gen(function* () {
+		if (yield* Ref.get(closing)) return yield* RunnerClosing.make({ detail: "The runner is closing" });
+	})));
+	const persist = (record) => store.save(record).pipe(Effect.tapCause(poison), Effect.andThen(Ref.update(records, (all) => save(all, record))));
+	const status = (handle) => Ref.get(records).pipe(Effect.flatMap((all) => {
+		const found = HashMap.get(all, handle.token);
+		return Option.isSome(found) && Equal.equals(keyOf(found.value.handle.key), keyOf(handle.key)) && found.value.handle.generation === handle.generation ? Effect.succeed(found.value) : Effect.fail(StaleSession.make({ detail: "Unknown session or generation" }));
+	}));
+	const latest = (key) => Ref.get(records).pipe(Effect.map((all) => Array.reduce(Array.fromIterable(HashMap.values(all)), 0, (value, record) => Equal.equals(keyOf(record.handle.key), keyOf(key)) ? Math.max(value, record.handle.generation) : value)));
+	const entryFor = (handle) => Effect.gen(function* () {
+		yield* status(handle);
+		const all = yield* Ref.get(entries);
+		const found = HashMap.get(all, handle.token);
+		if (Option.isNone(found)) return yield* SessionStopped.make({ detail: "The session was retired during recovery" });
+		return found.value;
+	});
+	const commit = (entry, transition) => SynchronizedRef.updateEffect(entry.state, (state) => Effect.gen(function* () {
+		const next = yield* Effect.fromResult(transition(state));
+		yield* persist(snapshot(next));
+		return next;
+	}));
+	const finishStop = (entry, state, saved) => Effect.gen(function* () {
+		yield* FiberHandle.clear(entry.loading);
+		const result = yield* terminate(state.execution, grace, confirmation);
+		const closed = yield* Effect.exit(close(entry.unitScope, Exit.void));
+		const termination = {
+			...result,
+			cause: Cause.combine(result.cause, exitCause(closed))
+		};
+		const record = stoppedRecord(state.record.previous, state.record.reason, termination);
+		yield* SynchronizedRef.updateEffect(entry.state, () => persist(record).pipe(Effect.as(Session.Stopped({
+			record,
+			reply: state.reply
+		}))));
+		if (Exit.isFailure(saved)) return yield* Effect.failCause(saved.cause);
+		return termination;
+	});
+	/** Called with the session ref locked; the worker starts after its transition is published. */
+	const stopLocked = (entry, state, reason, exit) => Effect.gen(function* () {
+		if (state._tag === "Stopping" || state._tag === "Stopped") return [state.reply, state];
+		const reply = yield* Deferred.make();
+		const next = beginStop(state, reason, reply, exit);
+		const saved = yield* Effect.exit(persist(next.record));
+		yield* FiberSet.run(workers, finishStop(entry, next, saved).pipe(Effect.onExit((result) => Deferred.done(reply, result)), observe), { startImmediately: false });
+		return [reply, next];
+	});
+	const stop = (entry, reason, exit = Option.none()) => SynchronizedRef.modifyEffect(entry.state, (state) => stopLocked(entry, state, reason, exit)).pipe(Effect.uninterruptible);
+	const scheduleLease = (entry, deadline) => FiberHandle.run(entry.timer, observe(Effect.gen(function* () {
+		const now = yield* Clock.monotonicTimeNanos;
+		yield* Effect.sleep(Duration.nanos(deadline > now ? deadline - now : 0n));
+		yield* SynchronizedRef.updateEffect(entry.state, (state) => {
+			if (state._tag === "Stopping" || state._tag === "Stopped" || state.deadline !== deadline) return Effect.succeed(state);
+			return stopLocked(entry, state, { _tag: "Expired" }, Option.none()).pipe(Effect.map(([, next]) => next));
+		});
+	})), { startImmediately: false });
+	const register = (entry, unit) => SynchronizedRef.updateEffect(entry.state, (state) => Effect.gen(function* () {
+		const now = yield* Clock.monotonicTimeNanos;
+		const current = yield* Effect.fromResult(live(state, now));
+		const next = yield* Effect.fromResult(registerUnit(current, unit));
+		yield* unit.renew(Number(current.deadline - (yield* Clock.monotonicTimeNanos)) / 1e6);
+		yield* persist(snapshot(next));
+		yield* FiberSet.run(workers, observe(unit.exited.pipe(Effect.flatMap((exit) => stop(entry, { _tag: "Exited" }, Option.some(exit))))));
+		return next;
+	})).pipe(Effect.uninterruptible);
+	const runLoad = (entry, state) => execution.spawn(state.record.handle, state.request, state.record.limits).pipe(Scope.provide(entry.unitScope), Effect.flatMap((unit) => register(entry, unit).pipe(Effect.andThen(unit.start), Effect.as(unit.code))), Effect.tap((code) => commit(entry, (current) => loaded(current, code))), Effect.onExit((result) => Effect.gen(function* () {
+		if (Exit.isSuccess(result)) {
+			yield* Deferred.done(state.reply, result);
+			return;
+		}
+		if ((yield* SynchronizedRef.get(entry.state))._tag === "Loading") yield* stop(entry, {
+			_tag: "LoadFailed",
+			cause: result.cause
+		});
+		const healthCause = yield* health.cause;
+		yield* Deferred.failCause(state.reply, Cause.combine(result.cause, healthCause));
+	})), Effect.exit, Effect.asVoid);
+	return {
+		persist,
+		status,
+		latest,
+		entryFor,
+		stop,
+		scheduleLease,
+		runLoad,
+		healthy
+	};
+};
+const recover = (runtime, actions) => Effect.gen(function* () {
+	const { store, execution, confirmation, records } = runtime;
+	const { persist } = actions;
+	const stored = yield* store.list;
+	yield* Ref.set(records, HashMap.fromIterable(Array.map(stored, (record) => [record.handle.token, record])));
+	for (const record of stored) {
+		if (record.phase === "Stopped") continue;
+		const child = childOf(record);
+		const termination = Option.isNone(child) ? emptyTermination : yield* execution.recover(child.value).pipe(Effect.timeout(confirmation), Effect.catchTags({
+			ExecutionError: (error) => Effect.fail(TerminationUnconfirmed.make({
+				detail: "Orphan recovery did not confirm exit",
+				cause: Cause.fail(error)
+			})),
+			TimeoutError: (error) => Effect.fail(TerminationUnconfirmed.make({
+				detail: "Orphan recovery did not confirm exit",
+				cause: Cause.fail(error)
+			}))
+		}));
+		yield* persist(stoppedRecord(record.phase === "Stopping" ? record.previous : record, { _tag: "Recovery" }, termination));
+	}
+});
+const ownShutdown = (runtime, actions) => Effect.gen(function* () {
+	const { entries, health, closing } = runtime;
+	const { stop } = actions;
+	yield* Effect.addFinalizer(() => Effect.gen(function* () {
+		yield* Ref.set(closing, true);
+		const all = yield* Ref.get(entries);
+		const exits = yield* Effect.forEach(HashMap.values(all), (entry) => stop(entry, { _tag: "Shutdown" }).pipe(Effect.flatMap(Deferred.await), Effect.exit));
+		const initial = yield* health.cause;
+		const cause = Array.reduce(exits, initial, (cause, exit) => Cause.combine(cause, Exit.isFailure(exit) ? exit.cause : exit.value.cause));
+		if (cause.reasons.length > 0) return yield* Effect.failCause(cleanupCause(cause));
+	}));
+});
+const protocol = (runtime, actions) => Effect.gen(function* () {
+	const { random, owner, locks, lease, limits, records, entries, health } = runtime;
+	const { persist, status, latest, entryFor, stop, scheduleLease, runLoad, healthy } = actions;
+	return Supervisor.of({
+		await: health.await,
+		status,
+		highWater: (key) => latest(key).pipe(Effect.map((value) => value === 0 ? null : value)),
+		open: (request) => Effect.scoped(Effect.gen(function* () {
+			yield* healthy;
+			const leaseMillis = Duration.toMillis(request.lease ?? lease);
+			const negotiated = negotiate(limits, request.limits ?? defaults);
+			return yield* (yield* RcMap.get(locks, keyOf(request.key))).withPermit(Effect.gen(function* () {
+				yield* healthy;
+				const allRecords = yield* Ref.get(records);
+				const same = Array.filter(Array.fromIterable(HashMap.values(allRecords)), (row) => Equal.equals(keyOf(row.handle.key), keyOf(request.key)));
+				const prior = Array.findFirst(same, (row) => row.requestId === request.requestId);
+				if (Option.isSome(prior)) return prior.value;
+				const generation = yield* latest(request.key);
+				if (generation !== (request.expectedGeneration ?? 0)) return yield* StaleSession.make({ detail: "Open expectedGeneration does not match the generation high-water mark" });
+				for (const record of same) {
+					const allEntries = yield* Ref.get(entries);
+					const entry = HashMap.get(allEntries, record.handle.token);
+					if (Option.isSome(entry)) yield* stop(entry.value, { _tag: "Superseded" }).pipe(Effect.flatMap(Deferred.await), Effect.tap((result) => result.cause.reasons.length === 0 ? Effect.void : Effect.logWarning("Superseded remote execution cleanup failed", result.cause).pipe(Effect.annotateLogs({
+						"remote.identity": record.handle.key.identity,
+						"remote.instance": record.handle.key.instance,
+						"remote.generation": record.handle.generation
+					}))));
+				}
+				yield* healthy;
+				const token = yield* random.uuidV4();
+				const record = {
+					version: 1,
+					phase: "Open",
+					handle: {
+						key: request.key,
+						token,
+						generation: generation + 1
+					},
+					requestId: request.requestId,
+					leaseMillis,
+					limits: negotiated
+				};
+				return yield* Effect.uninterruptible(Effect.gen(function* () {
+					yield* persist(record);
+					const deadline = (yield* Clock.monotonicTimeNanos) + nanos(leaseMillis);
+					const scope = yield* Scope.fork(owner);
+					const entry = {
+						state: yield* SynchronizedRef.make(Session.Open({
+							record,
+							deadline
+						})),
+						scope,
+						unitScope: yield* Scope.fork(scope),
+						timer: yield* FiberHandle.make().pipe(Scope.provide(scope)),
+						loading: yield* FiberHandle.make().pipe(Scope.provide(scope))
+					};
+					const retained = yield* Ref.get(records);
+					const old = yield* Ref.modify(entries, (all) => [Array.filter(Array.fromIterable(HashMap.entries(all)), ([key]) => !HashMap.has(retained, key)), HashMap.set(HashMap.filter(all, (_, key) => HashMap.has(retained, key)), token, entry)]);
+					for (const [, retired] of old) yield* close(retired.scope, Exit.void);
+					yield* scheduleLease(entry, deadline);
+					return record;
+				}));
+			}));
+		})),
+		renew: (handle) => Effect.gen(function* () {
+			yield* healthy;
+			const entry = yield* entryFor(handle);
+			return yield* SynchronizedRef.modifyEffect(entry.state, (state) => Effect.gen(function* () {
+				const now = yield* Clock.monotonicTimeNanos;
+				const current = yield* Effect.fromResult(live(state, now));
+				const running = executionOf(current);
+				if (running._tag === "Running") yield* running.unit.renew(current.record.leaseMillis);
+				const deadline = now + nanos(current.record.leaseMillis);
+				yield* scheduleLease(entry, deadline);
+				return [current.record.leaseMillis, {
+					...current,
+					deadline
+				}];
+			}));
+		}),
+		load: (handle, request) => Effect.gen(function* () {
+			yield* healthy;
+			const entry = yield* entryFor(handle);
+			return yield* yield* SynchronizedRef.modifyEffect(entry.state, (state) => Effect.gen(function* () {
+				const now = yield* Clock.monotonicTimeNanos;
+				const current = yield* Effect.fromResult(live(state, now));
+				if (current._tag !== "Open") {
+					if ((current._tag === "Loading" ? current.request : current.record.load).specifier !== request.specifier) return yield* SessionConflict.make({ detail: "Load was already requested with a different specifier" });
+					return [current._tag === "Loading" ? Deferred.await(current.reply) : Effect.succeed(current.record.code), current];
+				}
+				const done = yield* Deferred.make();
+				const next = beginLoad(current, request, done);
+				yield* persist(snapshot(next));
+				if (next._tag === "Loading") yield* FiberHandle.run(entry.loading, runLoad(entry, next), { startImmediately: false });
+				return [Deferred.await(done), next];
+			})).pipe(Effect.uninterruptible);
+		}),
+		dispose: (handle) => Effect.gen(function* () {
+			const record = yield* status(handle);
+			if (record.phase === "Stopped") return record.termination;
+			const entry = yield* entryFor(handle);
+			return yield* stop(entry, { _tag: "Disposed" }).pipe(Effect.flatMap(Deferred.await));
+		})
+	});
+});
+const make = (options = {}) => Effect.gen(function* () {
+	const runtime = yield* initialize(options);
+	const actions = operations(runtime);
+	yield* recover(runtime, actions);
+	yield* ownShutdown(runtime, actions);
+	return yield* protocol(runtime, actions);
+});
+const layer = (options = {}) => Layer.effect(Supervisor, make(options));
+// packages/remote/src/internal/runner/accept.ts
+const accept = (supervisor, execution, channel$1) => Effect.gen(function* () {
+	const identity = yield* Peer;
+	const scope = yield* Effect.scope;
+	const mux = yield* make$3(channel$1);
+	const peer = yield* make$5(channel(mux, 0), {
+		session: "session-v1",
+		serve: { session: Session$1 },
+		call: {}
+	});
+	const attached = yield* Ref.make(Option.none());
+	const loading = yield* Semaphore.make(1);
+	const authorize = (handle) => handle.key.identity === identity ? Effect.void : Effect.fail(SessionAccessDenied.make({ detail: "The session belongs to another authenticated identity" }));
+	const handlers = yield* Session$1.toHandlers({
+		HighWater: ({ instance }) => supervisor.highWater({
+			identity,
+			instance
+		}),
+		Open: ({ instance, requestId, expectedGeneration, leaseMillis, limits }) => supervisor.open({
+			key: {
+				identity,
+				instance
+			},
+			requestId,
+			expectedGeneration,
+			...leaseMillis === void 0 ? {} : { lease: leaseMillis },
+			limits
+		}),
+		Load: ({ handle, ...request }) => Effect.gen(function* () {
+			yield* authorize(handle);
+			const attachment = yield* Ref.get(attached);
+			if (Option.isSome(attachment) && attachment.value !== handle.token) return yield* SessionConflict.make({ detail: "A connection can attach only one execution" });
+			const code = yield* supervisor.load(handle, request);
+			if (Option.isNone(attachment)) {
+				const child = yield* execution.peer(handle.token).pipe(Scope.provide(scope));
+				yield* Ref.set(attached, Option.some(handle.token));
+				yield* Effect.all([Effect.forever(Effect.flatMap(mux.take(1), (bytes) => child.send(1, bytes))), Effect.forever(Effect.flatMap(child.take(1), (bytes) => mux.send(1, bytes)))], { concurrency: "unbounded" }).pipe(Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : child.fail(TransportError.make({ cause }))), Effect.forkIn(scope));
+			}
+			return code;
+		}).pipe(loading.withPermit),
+		Renew: (handle) => authorize(handle).pipe(Effect.andThen(supervisor.renew(handle))),
+		Dispose: (handle) => authorize(handle).pipe(Effect.andThen(supervisor.dispose(handle))),
+		Status: (handle) => authorize(handle).pipe(Effect.andThen(supervisor.status(handle)))
+	});
+	return yield* RpcServer.make(Session$1, { disableFatalDefects: true }).pipe(Effect.provideContext(handlers), Effect.provideService(RpcServer.Protocol, peer.serverProtocol("session")), Effect.raceFirst(mux.await));
+});
+// packages/remote/src/internal/supervisorPlugin.ts
+const Config$1 = Schema.Struct({
+	root: Schema.String,
+	state: Schema.String,
+	lease: Schema.optionalKey(PositiveDuration),
+	grace: Schema.optionalKey(PositiveDuration)
+});
+var supervisorPlugin_default = make$2({
+	name: "remote-supervisor",
+	config: Config$1,
+	inject: [
+		optional(ServeLifecycle),
+		FileSystem.FileSystem,
+		Path.Path,
+		ChildProcessSpawner.ChildProcessSpawner,
+		SecureRandom.SecureRandom,
+		Digest.Digest
+	],
+	apply: Effect.fnUntraced(function* (options) {
+		const lifecycle = yield* Effect.serviceOption(ServeLifecycle);
+		const resources$1 = yield* resources(lifecycle);
+		const path = yield* Path.Path;
+		const directory = yield* ConfigDirectory.pipe(Effect.map(Option.getOrElse(() => ".")));
+		const state = path.resolve(directory, options.state);
+		yield* acquire(state).pipe(Scope.provide(resources$1));
+		const services = yield* Layer.build(layer(options).pipe(Layer.provideMerge(Layer.merge(layerDirectory(state), layer$1(path.resolve(directory, options.root)))))).pipe(Scope.provide(resources$1));
+		const engine = Context.get(services, Supervisor);
+		const execution = Context.get(services, Channels);
+		yield* fork(engine.await);
+		yield* provide(Supervisor$1, { accept: (channel) => accept(engine, execution, channel) });
+	})
+});
+export { supervisorPlugin_default as n, Config$1 as t };