@graftland/plugin-remote 0.3.3 → 0.4.0

package/dist/supervisorPlugin-t6Z6PrhD.js

@@ -1,733 +0,0 @@
-import { a as provide, l as make$2, o as fork, u as optional } from "./Graft-B71CPA2Y.js";
-import { a as PositiveDuration, i as Supervisor$1, t as resolve } from "./Packages-AgoCGotL.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-DXeVrGBh.js";
-import { t as observe } from "./ProcessObservation-gLgGirYv.js";
-import { r as cleanupCause, t as make$4 } from "./FailureGroup-BgT73AaR.js";
-import { t as CommandJson } from "./WatchdogProtocol-BZmVxrBP.js";
-import { u as TransportError } from "./Errors-DYhsGZcZ.js";
-import { t as Bootstrap } from "./Bootstrap-H9gDsgsC.js";
-import { t as command } from "./command-9zrHdbwT.js";
-import { n as close } from "./release-DfZPuIcK.js";
-import { n as make$5, o as defaults } from "./port--3x2zJ4D.js";
-import { i as resources, t as ServeLifecycle } from "./ServeLifecycle-Bd1FPJ6e.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 = Effect.fnUntraced(function* (directory) {
-	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 = Effect.fnUntraced(function* (root) {
-	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: Effect.fnUntraced(function* (record) {
-			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;
-		}, Effect.scoped, mutex.withPermit, storage)
-	});
-});
-Layer.effect(Store, memory);
-const layerDirectory = (root) => Layer.effect(Store, directory(root));
-// packages/remote/src/internal/runner/Processes.ts
-const inspect = Effect.fnUntraced(function* (pid) {
-	const child = yield* (yield* ChildProcessSpawner.ChildProcessSpawner).spawn(ChildProcess.make("ps", [
-		"-p",
-		`${pid}`,
-		"-o",
-		"lstart=",
-		"-o",
-		"stat="
-	], {
-		env: { LC_ALL: "C" },
-		extendEnv: true,
-		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 });
-}, Effect.scoped, Effect.mapError((error) => error._tag === "ExecutionError" ? error : ExecutionError.make({
-	detail: "Inspecting process identity failed",
-	cause: Cause.fail(error)
-})));
-const identity = Effect.fnUntraced(function* (pid) {
-	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 = Effect.fnUntraced(function* (child) {
-	const current = yield* inspect(child.pid);
-	if (Option.isNone(current) || current.value.born !== child.start.born) return false;
-	return true;
-});
-const recover$1 = Effect.fnUntraced(function* (child) {
-	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 = Effect.fnUntraced(function* (root) {
-	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: Effect.fnUntraced(function* (handle, request, limits) {
-				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
-					})
-				};
-			}, 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 = Effect.fnUntraced(function* (execution, grace, confirmation) {
-	if (execution._tag === "Absent") return emptyTermination;
-	if (execution._tag === "Exited") return {
-		...emptyTermination,
-		exit: execution.exit
-	};
-	const child = execution.unit;
-	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 = Effect.fnUntraced(function* (options = {}) {
-	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 = Effect.fnUntraced(function* (handle) {
-		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, Effect.fnUntraced(function* (state) {
-		const next = yield* Effect.fromResult(transition(state));
-		yield* persist(snapshot(next));
-		return next;
-	}));
-	const finishStop = Effect.fnUntraced(function* (entry, state, saved) {
-		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 = Effect.fnUntraced(function* (entry, state, reason, exit) {
-		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, Effect.fnUntraced(function* (state) {
-		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(Effect.fnUntraced(function* (result) {
-		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 = Effect.fnUntraced(function* (runtime, actions) {
-	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 = Effect.fnUntraced(function* (runtime, actions) {
-	const { entries, health, closing } = runtime;
-	const { stop } = actions;
-	yield* Effect.addFinalizer(Effect.fnUntraced(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 = Effect.fnUntraced(function* (runtime, actions) {
-	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: Effect.fnUntraced(function* (request) {
-			yield* healthy;
-			const leaseMillis = Duration.toMillis(request.lease ?? lease);
-			const negotiated = negotiate(limits, request.limits ?? defaults);
-			const lock = yield* RcMap.get(locks, keyOf(request.key));
-			return yield* 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;
-				}));
-			}).pipe(lock.withPermit);
-		}, Effect.scoped),
-		renew: Effect.fnUntraced(function* (handle) {
-			yield* healthy;
-			const entry = yield* entryFor(handle);
-			return yield* Effect.uninterruptibleMask((restore) => SynchronizedRef.modifyEffect(entry.state, Effect.fnUntraced(function* (state) {
-				const now = yield* Clock.monotonicTimeNanos;
-				const current = yield* Effect.fromResult(live(state, now));
-				const running = executionOf(current);
-				if (running._tag === "Running") yield* restore(running.unit.renew(current.record.leaseMillis));
-				const deadline = now + nanos(current.record.leaseMillis);
-				yield* scheduleLease(entry, deadline);
-				return [current.record.leaseMillis, {
-					...current,
-					deadline
-				}];
-			})));
-		}),
-		load: Effect.fnUntraced(function* (handle, request) {
-			yield* healthy;
-			const entry = yield* entryFor(handle);
-			return yield* yield* SynchronizedRef.modifyEffect(entry.state, Effect.fnUntraced(function* (state) {
-				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: Effect.fnUntraced(function* (handle) {
-			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 = Effect.fnUntraced(function* (options = {}) {
-	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 = Effect.fnUntraced(function* (supervisor, execution, channel$1) {
-	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: Effect.fnUntraced(function* ({ handle, ...request }) {
-			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;
-		}, 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 };