@graftland/plugin-remote 0.0.0-stage → 0.3.0

package/dist/Graft-BsYq3F-J.js

@@ -0,0 +1,985 @@
+import { Array, Cause, Context, Data, Deferred, Duration, Effect, Equal, Exit, Fiber, FiberSet, HashMap, HashSet, Layer, Logger, Option, Order, Predicate, PubSub, Pull, Record, Ref, References, Result, Schedule, Schema, Scope, Stream, TxRef, TxSubscriptionRef } from "effect";
+import { identity } from "effect/Function";
+// packages/core/src/Fork.ts
+const ForkState = Data.taggedEnum();
+/** A disposal failure retains the original typed errors, defects, and interruption reasons. */
+var CleanupError = class extends Schema.TaggedError()("CleanupError", { cause: Schema.Cause(Schema.Unknown, Schema.Unknown) }) {
+	get message() {
+		return "Plugin cleanup failed";
+	}
+};
+// packages/core/src/internal/dependencies.ts
+/** The exact dependency snapshot must still be valid when plugin code publishes. */
+const resolutionChanged = Effect.fnUntraced(function* (resolution) {
+	for (const provision of resolution.provisions) {
+		const current = yield* TxRef.get(provision.slot.provision);
+		if (!Option.exists(current, (current) => current === provision)) return true;
+	}
+	for (const slot of HashMap.values(resolution.watch)) {
+		const current = yield* TxRef.get(slot.provision);
+		if (Option.isSome(current)) return true;
+	}
+	return false;
+});
+/** Reverse reachability reads only nodes that can affect this publisher. Call within a transaction. */
+const publicationCycle = Effect.fnUntraced(function* (publisher, key, candidate) {
+	let pending = {
+		node: publisher,
+		next: void 0
+	};
+	let seen = HashSet.empty();
+	while (pending !== void 0) {
+		const node = pending.node;
+		pending = pending.next;
+		if (HashSet.has(seen, node.id)) continue;
+		seen = HashSet.add(seen, node.id);
+		const state = yield* TxRef.get(node.state);
+		if (!state.live) continue;
+		const resolution = node === publisher && candidate !== void 0 ? candidate : state.resolution;
+		if (resolution !== void 0) {
+			if (HashMap.has(resolution.watch, key)) return true;
+			for (const provision of resolution.provisions) pending = {
+				node: provision.node,
+				next: pending
+			};
+		}
+		if (node.parent !== void 0) pending = {
+			node: node.parent,
+			next: pending
+		};
+	}
+	return false;
+});
+// packages/core/src/internal/slots.ts
+/** Call inside a transaction before waiting; the directory must stay out of waiting read sets. */
+const retain = Effect.fnUntraced(function* (runtime, key) {
+	const directory = yield* TxRef.get(runtime.slots);
+	const existing = HashMap.get(directory, key);
+	if (Option.isSome(existing)) {
+		yield* TxRef.update(existing.value.holders, (count) => count + 1);
+		return existing.value;
+	}
+	const slot = {
+		key,
+		provision: TxRef.makeUnsafe(Option.none()),
+		holders: TxRef.makeUnsafe(1)
+	};
+	yield* TxRef.set(runtime.slots, HashMap.set(directory, key, slot));
+	return slot;
+});
+/** Every holder, including a publisher, releases in the same transaction as its last use. */
+const release = Effect.fnUntraced(function* (runtime, slot) {
+	const count = yield* TxRef.get(slot.holders);
+	yield* TxRef.set(slot.holders, count - 1);
+	if (count === 1) {
+		const provision = yield* TxRef.get(slot.provision);
+		if (Option.isNone(provision)) yield* TxRef.update(runtime.slots, HashMap.remove(slot.key));
+	}
+});
+// packages/core/src/internal/aliases.ts
+/** Weak keys are necessary: an obsolete plugin must not be retained by the alias registry. */
+const make$3 = () => ({ identities: /* @__PURE__ */ new WeakMap() });
+const makeGroup = (target) => ({ state: TxRef.makeUnsafe({
+	_tag: "Root",
+	target,
+	rank: 0
+}) });
+const identity$1 = (aliases, plugin) => {
+	const existing = aliases.identities.get(plugin);
+	if (existing !== void 0) return existing;
+	const cell = TxRef.makeUnsafe(makeGroup(plugin));
+	aliases.identities.set(plugin, cell);
+	return cell;
+};
+const resolve$1 = Effect.fnUntraced(function* (aliases, plugin) {
+	let group = yield* TxRef.get(identity$1(aliases, plugin));
+	while (true) {
+		const state = yield* TxRef.get(group.state);
+		if (state._tag === "Root") return state.target;
+		group = state.group;
+	}
+});
+/**
+* Stages a flat-alias transition before touching transaction state. A caller may
+* catch a conflict inside an outer transaction without accidentally committing
+* the rejected aliases. Successful writes share the caller's transaction.
+*/
+const replace$1 = Effect.fnUntraced(function* (aliases, pairs) {
+	let cells = HashMap.empty();
+	let groups = HashMap.empty();
+	const readCell = (cell) => Option.match(HashMap.get(cells, cell), {
+		onNone: () => TxRef.get(cell),
+		onSome: Effect.succeed
+	});
+	const readGroup = (group) => Option.match(HashMap.get(groups, group), {
+		onNone: () => TxRef.get(group.state),
+		onSome: Effect.succeed
+	});
+	const root = Effect.fnUntraced(function* (cell) {
+		let group = yield* readCell(cell);
+		while (true) {
+			const state = yield* readGroup(group);
+			if (state._tag === "Root") return {
+				group,
+				state
+			};
+			group = state.group;
+		}
+	});
+	const current = yield* Effect.forEach(pairs, ([from]) => resolve$1(aliases, from));
+	for (const [from, to] of pairs) {
+		const targetCell = identity$1(aliases, to);
+		let target = yield* root(targetCell);
+		if (target.state.target !== to) {
+			const group = makeGroup(to);
+			cells = HashMap.set(cells, targetCell, group);
+			target = yield* root(targetCell);
+		}
+		if (from === to) continue;
+		const sourceCell = identity$1(aliases, from);
+		const source = yield* root(sourceCell);
+		if (source.state.target !== from) cells = HashMap.set(cells, sourceCell, target.group);
+		else if (source.group !== target.group) {
+			const winner = source.state.rank > target.state.rank ? source : target;
+			const loser = winner === source ? target : source;
+			groups = HashMap.set(groups, loser.group, {
+				_tag: "Link",
+				group: winner.group
+			});
+			groups = HashMap.set(groups, winner.group, {
+				_tag: "Root",
+				target: to,
+				rank: winner.state.rank + (source.state.rank === target.state.rank ? 1 : 0)
+			});
+		}
+	}
+	const checks = yield* Effect.forEach(pairs, ([from, to], index) => Effect.gen(function* () {
+		const overlap = from !== to && Array.some(pairs, ([other, target]) => other !== target && (to === other || from === target));
+		const source = yield* root(identity$1(aliases, from));
+		const previous = yield* root(identity$1(aliases, current[index]));
+		const target = yield* root(identity$1(aliases, to));
+		return overlap || source.state.target !== to || previous.state.target !== to || target.state.target !== to ? Option.some(index) : Option.none();
+	}));
+	const conflicts = Array.getSomes(checks);
+	if (conflicts.length > 0) return conflicts;
+	for (const [cell, group] of cells) yield* TxRef.set(cell, group);
+	for (const [group, state] of groups) yield* TxRef.set(group.state, state);
+	return conflicts;
+});
+// packages/core/src/internal/release.ts
+/** Resource release was interrupted, rather than successfully cancelled. */
+var ReleaseInterrupted = class extends Schema.TaggedError()("ReleaseInterrupted", { cause: Schema.Cause(Schema.Never, Schema.Unknown) }) {
+	get message() {
+		return "Resource release was interrupted";
+	}
+};
+/** Keep a known release failure distinguishable from cancellation through enclosing scopes. */
+const close = (scope, exit) => Effect.uninterruptible(Scope.close(scope, exit).pipe(Effect.catchCauseIf(Cause.hasInterruptsOnly, (cause) => Effect.gen(function* () {
+	const pending = yield* Effect.exit(Effect.interruptible(Effect.void));
+	const [cancelled, interrupted] = Array.partition(cause.reasons, (reason) => Exit.isFailure(pending) && Array.some(pending.cause.reasons, (external) => reason._tag === "Interrupt" && external._tag === "Interrupt" && reason.fiberId === external.fiberId) ? Result.succeed(reason) : Result.fail(reason));
+	if (interrupted.length === 0) return yield* Effect.failCause(cause);
+	return yield* Effect.failCause(Cause.combine(Cause.fromReasons(cancelled), Cause.die(ReleaseInterrupted.make({ cause: Cause.fromReasons(interrupted) }))));
+}))));
+// packages/core/src/internal/scope.ts
+/** Keep ownership until cleanup finishes, even if a dispose caller is cancelled. */
+const ownedScope = Effect.fnUntraced(function* (parent, afterClose = Effect.void) {
+	const link = yield* Scope.fork(parent);
+	const scope = yield* Scope.make();
+	const workers = yield* Scope.make();
+	const started = yield* Deferred.make();
+	const ready = yield* Deferred.make();
+	const completed = yield* Deferred.make();
+	const start = (exit) => Effect.gen(function* () {
+		if (!(yield* Deferred.succeed(started, void 0))) return;
+		yield* Effect.gen(function* () {
+			const result = yield* Effect.exit(Effect.gen(function* () {
+				const closed = yield* Effect.exit(close(scope, exit));
+				const observed = yield* Effect.exit(afterClose);
+				if (Exit.isFailure(closed)) return yield* Effect.failCause(Exit.isFailure(observed) ? Cause.combine(closed.cause, observed.cause) : closed.cause);
+				if (Exit.isFailure(observed)) return yield* Effect.failCause(observed.cause);
+			}));
+			yield* Deferred.done(ready, result);
+			yield* close(link, exit).pipe(Effect.catchCause((cause) => Effect.logError("Closing fork ownership failed", cause)));
+			yield* Deferred.done(completed, result);
+		}).pipe(Effect.forkIn(workers, {
+			uninterruptible: true,
+			startImmediately: false
+		}));
+	});
+	const close$1 = (exit) => Effect.uninterruptibleMask((restore) => start(exit).pipe(Effect.andThen(restore(Deferred.await(completed)))));
+	yield* Scope.addFinalizerExit(link, (exit) => start(exit).pipe(Effect.andThen(Deferred.await(ready)), Effect.orDie, Effect.ensuring(close(workers, exit))));
+	return {
+		scope,
+		close: close$1
+	};
+});
+// packages/core/src/internal/forkState.ts
+/** Update ancestors in the same transaction as the state or topology change. */
+const adjustLoading = Effect.fnUntraced(function* (status, delta) {
+	if (delta === 0) return;
+	for (let current = status; current !== void 0; current = current.parent) {
+		if ((yield* TxSubscriptionRef.get(current.snapshot)).disposed) return;
+		yield* TxRef.update(current.loading, (count) => count + delta);
+	}
+});
+/** Called inside the fork registration transaction. */
+const make$2 = Effect.fnUntraced(function* (parent, spec) {
+	const status = {
+		parent,
+		loading: yield* TxRef.make(0),
+		snapshot: yield* TxSubscriptionRef.make({
+			state: ForkState.Loading(),
+			accepted: void 0,
+			name: spec.plugin.name,
+			input: spec.input,
+			disposed: false
+		})
+	};
+	yield* adjustLoading(status, 1);
+	return status;
+});
+const setState = (runtime, id, status, state, spec) => Effect.tx(Effect.gen(function* () {
+	const current = yield* TxSubscriptionRef.get(status.snapshot);
+	if (current.disposed) return;
+	const next = {
+		state,
+		accepted: spec,
+		name: spec.plugin.name,
+		input: spec.input,
+		disposed: false
+	};
+	yield* adjustLoading(status, Number(state._tag === "Loading") - Number(current.state._tag === "Loading"));
+	yield* TxSubscriptionRef.set(status.snapshot, next);
+	yield* TxSubscriptionRef.update(runtime.forks, (forks) => HashMap.modify(forks, id, (entry) => ({
+		...entry,
+		...next
+	})));
+}));
+/** Called inside the removal transaction, after supervisor cleanup. */
+const dispose = Effect.fnUntraced(function* (runtime, id, status) {
+	const current = yield* TxSubscriptionRef.get(status.snapshot);
+	if (current.disposed) return;
+	const loading = yield* TxRef.get(status.loading);
+	yield* adjustLoading(status.parent, -loading);
+	yield* TxRef.set(status.loading, 0);
+	yield* TxSubscriptionRef.set(status.snapshot, {
+		...current,
+		state: ForkState.Disposed(),
+		disposed: true
+	});
+	yield* TxSubscriptionRef.update(runtime.forks, HashMap.remove(id));
+});
+/** Only the subtree's own counter belongs to this waiting transaction's read set. */
+const stable = (status) => Effect.tx(Effect.gen(function* () {
+	if ((yield* TxRef.get(status.loading)) > 0) return yield* Effect.txRetry;
+}));
+// packages/core/src/internal/context.ts
+/** Strip provision-sourced values before child intercepts read or transform the fallback. */
+const inheritContext = (parent, inherited) => Context.makeUnsafe(new Map([...Array.filter(parent.fallback.mapUnsafe, ([key]) => HashSet.has(parent.provisionKeys, key)), ...Array.filter(inherited.mapUnsafe, ([key]) => !HashSet.has(parent.provisionKeys, key))]));
+// packages/core/src/internal/tasks.ts
+/** One activation owns both the workers and every failure they finish with. */
+const make$1 = Effect.gen(function* () {
+	const scope = yield* Scope.make();
+	return {
+		scope,
+		fibers: yield* FiberSet.make().pipe(Scope.provide(scope)),
+		failures: yield* Ref.make(Cause.empty)
+	};
+});
+const run = (group, effect) => FiberSet.run(group.fibers, Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+	const scope = yield* Scope.make();
+	const body = yield* Effect.exit(restore(Scope.provide(scope)(effect)));
+	const closed = yield* Effect.exit(close(scope, body));
+	const failure = Cause.combine(Exit.isFailure(body) && !Cause.hasInterruptsOnly(body.cause) ? body.cause : Cause.empty, Exit.isFailure(closed) && !Cause.hasInterruptsOnly(closed.cause) ? closed.cause : Cause.empty);
+	if (failure.reasons.length > 0) {
+		yield* Ref.update(group.failures, (cause) => Cause.combine(cause, failure));
+		yield* Deferred.failCause(group.fibers.deferred, failure);
+		yield* Effect.logError("The plugin's background task failed", failure);
+	}
+	if (Exit.isFailure(closed)) return yield* Effect.failCause(Exit.isFailure(body) ? Cause.combine(body.cause, closed.cause) : closed.cause);
+	return yield* body;
+})), { startImmediately: false });
+// packages/core/src/Plugin.ts
+const TypeId = "~@graftland/graft/Plugin";
+const Contract = "~@graftland/graft/Plugin/Contract";
+/**
+* Marks a dependency as optional: the plugin starts without it and restarts
+* whenever it appears or disappears. Read it with `Effect.serviceOption`.
+*/
+var Optional = class extends Data.TaggedClass("Optional") {};
+/** Starts an activation-owned worker. Its unhandled errors belong to the plugin, not the launch operation. */
+const fork = (effect) => Effect.gen(function* () {
+	const { activation } = yield* Graft;
+	if (Option.isNone(activation.tasks)) return yield* Effect.die(/* @__PURE__ */ new Error("Plugin.fork requires a plugin activation"));
+	return yield* run(activation.tasks.value, effect);
+});
+const isPlugin = (u) => Predicate.hasProperty(u, TypeId);
+/** The plugin a module exports: its default export, or else an export named `plugin`. */
+const fromModule = (module) => Array.findFirst([Predicate.hasProperty(module, "default") ? module.default : void 0, Predicate.hasProperty(module, "plugin") ? module.plugin : void 0], isPlugin);
+const optional = (key) => new Optional({ key });
+const isOptional = (dependency) => "_tag" in dependency && dependency._tag === "Optional";
+/**
+* Defines a plugin. `apply` may only require what `inject` declares as
+* required; anything else is a type error.
+*/
+const make = (options) => {
+	const schema = options.config;
+	return Equal.byReference({
+		[TypeId]: TypeId,
+		[Contract]: {
+			input: identity,
+			error: identity
+		},
+		name: options.name,
+		inject: options.inject ?? [],
+		retry: options.retry,
+		decode: schema === void 0 ? Effect.succeed : Schema.decodeUnknownEffect(schema),
+		apply: options.apply
+	});
+};
+/** A plugin that builds one service with a scoped effect and publishes it. */
+const service = (key, build, options) => make({
+	...options,
+	apply: () => Effect.flatMap(build, (value) => provide(key, value))
+});
+// packages/core/src/internal/runtime.ts
+/** Maps a service key to the realm it resolves in. Absent keys use the root realm. */
+const Realms = Context.Reference("@graftland/graft/Realms", { defaultValue: () => HashMap.empty() });
+/** The realm a key resolves in; the root realm is the empty string. */
+const realmOf = (realms, key) => Option.getOrElse(HashMap.get(realms, key), () => "");
+/** The single constructor used by publication, resolution, and failed-publication retries. */
+const realmKey = (realm, service) => `${realm.length}:${realm}${service}`;
+// packages/core/src/internal/activation.ts
+/**
+* The supervision loop of a single fork.
+*
+* Each iteration acquires the fork's dependencies, runs `apply` in a fresh
+* activation, waits until the specification or a dependency changes, and
+* tears the activation down. Teardown follows a fixed order instead of
+* relying on finalizer registration order:
+*
+* 1. stop `apply` if it is still running;
+* 2. withdraw everything the activation published and close it to further
+*    publishing, so nobody new can lease it;
+* 3. wait until every consumer has released those provisions;
+* 4. stop supervised tasks and close their scopes, waiting for cleanup;
+* 5. close the activation scope (child forks, resources, handlers);
+* 6. release the leases the activation itself holds, whatever happened before.
+*
+* All phases contribute to one cleanup Exit. Failed state or fork disposal owns
+* that result; logging it is never a substitute for handing it to the caller.
+*/
+const interruptedBy = (cause, id) => Array.every(cause.reasons, (reason) => reason._tag === "Interrupt" && reason.fiberId === id);
+/** Observe cancellation without losing the child's final Exit at an interruption boundary. */
+const cancelOnChange = (operation, changed, handoff, observe = () => Effect.void) => Effect.scoped(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+	const id = yield* Effect.withFiber((self) => Effect.succeed(self.id));
+	const worker = yield* Effect.forkScoped(restore(operation));
+	const raced = yield* Effect.exit(restore(Effect.raceFirst(Effect.as(changed, true), Effect.as(Fiber.await(worker), false))));
+	yield* Fiber.interrupt(worker);
+	const result = yield* Fiber.await(worker);
+	yield* observe(result);
+	return yield* handoff(result, yield* Effect.exit(restore(raced)), restore, (cause) => interruptedBy(cause, id));
+})));
+/** How long teardown waits for consumers before warning about a possible cycle. */
+const drainWarning = Duration.seconds(10);
+const Outcome = Data.taggedEnum();
+const Acquired = Data.taggedEnum();
+/** A schedule belongs to one spec and the exact provisions that attempt used. */
+const sameAttempt = (left, right) => left.spec === right.spec && left.provisions.length === right.provisions.length && Array.every(left.provisions, (provision, index) => provision === right.provisions[index]) && Equal.equals(left.unprovided, right.unprovided);
+const restart = Outcome.Restart();
+const resolve = Effect.fnUntraced(function* (spec, prepared) {
+	const lookups = yield* Effect.forEach(prepared.lookups, (lookup) => Effect.map(TxRef.get(lookup.slot.provision), (found) => ({
+		...lookup,
+		found,
+		ambient: Option.isSome(found) ? Option.none() : lookup.ambient()
+	})));
+	const unresolved = Array.filter(lookups, (lookup) => Option.isNone(lookup.found));
+	const absent = Array.filter(unresolved, (lookup) => Option.isNone(lookup.ambient));
+	return {
+		prepared,
+		watch: HashMap.fromIterable(Array.map(unresolved, (lookup) => [lookup.qualified, lookup.slot])),
+		spec,
+		provisions: Array.getSomes(Array.map(lookups, (lookup) => lookup.found)),
+		ambient: Array.getSomes(Array.map(unresolved, (lookup) => Option.map(lookup.ambient, (value) => [lookup.service, value]))),
+		missing: Array.map(Array.filter(absent, (lookup) => !lookup.optional), (lookup) => lookup.service),
+		unprovided: Array.map(unresolved, (lookup) => lookup.qualified)
+	};
+});
+const waitDrained = (published) => Effect.tx(Effect.gen(function* () {
+	for (const provision of published) {
+		const consumers = yield* TxRef.get(provision.consumers);
+		if (HashSet.size(consumers) > 0) return yield* Effect.txRetry;
+	}
+}));
+/**
+* Withdraws what an activation published, closes it to further publishing,
+* and waits until no consumer holds a lease on any of it.
+*/
+const withdraw = Effect.fnUntraced(function* (runtime, activation) {
+	const published = yield* Effect.tx(Effect.gen(function* () {
+		const current = yield* TxRef.get(activation.published);
+		const published = Option.getOrElse(current, () => []);
+		yield* TxRef.set(activation.published, Option.none());
+		yield* TxRef.update(activation.node.state, (state) => ({
+			...state,
+			resolution: state.resolution === void 0 ? void 0 : {
+				...state.resolution,
+				watch: HashMap.empty()
+			}
+		}));
+		for (const provision of published) {
+			const current = yield* TxRef.get(provision.slot.provision);
+			if (Option.exists(current, (current) => current === provision)) yield* TxRef.set(provision.slot.provision, Option.none());
+			yield* release(runtime, provision.slot);
+		}
+		return published;
+	}));
+	const drained = yield* Effect.timeoutOption(waitDrained(published), drainWarning);
+	if (Option.isNone(drained)) {
+		const services = Array.join(Array.map(published, (provision) => provision.service), ", ");
+		yield* Effect.logWarning(`Still waiting for consumers of ${services}; a teardown cycle may be holding them`);
+		yield* waitDrained(published);
+	}
+});
+const reportFailure = (message, exit) => Exit.isFailure(exit) && !Cause.hasInterruptsOnly(exit.cause) ? Effect.logError(message, exit.cause) : Effect.void;
+const supervise = Effect.fnUntraced(function* (runtime, id, specRef, processing, node, status, completion) {
+	const cleanup = completion ?? (yield* Ref.make(Exit.void));
+	const realms = yield* Realms;
+	/** What the fork inherits from where it was loaded: references and ambient services. */
+	const inherited = yield* Effect.context();
+	const references = Context.merge(runtime.ambient, inherited);
+	const held = yield* TxRef.make(void 0);
+	const prepare = Effect.gen(function* () {
+		const spec = yield* TxRef.get(specRef);
+		const previous = yield* TxRef.get(held);
+		if (previous?.plugin === spec.plugin) return previous;
+		let slots = HashMap.empty();
+		const lookups = yield* Effect.forEach(spec.plugin.inject, (dependency) => Effect.gen(function* () {
+			const key = isOptional(dependency) ? dependency.key : dependency;
+			const qualified = realmKey(realmOf(realms, key.key), key.key);
+			const existing = HashMap.get(slots, qualified);
+			const slot = Option.isSome(existing) ? existing.value : yield* retain(runtime, qualified);
+			slots = HashMap.set(slots, qualified, slot);
+			return {
+				optional: isOptional(dependency),
+				service: key.key,
+				qualified,
+				slot,
+				ambient: () => Context.getOption(Context.isReference(key) ? references : runtime.ambient, key)
+			};
+		}));
+		if (previous !== void 0) for (const slot of HashMap.values(previous.slots)) yield* release(runtime, slot);
+		const prepared = {
+			plugin: spec.plugin,
+			slots,
+			lookups
+		};
+		yield* TxRef.set(held, prepared);
+		return prepared;
+	});
+	const resolveCurrent = (prepared) => Effect.flatMap(TxRef.get(specRef), (spec) => resolve(spec, prepared));
+	/** Resolves to the new spec if the spec changed, or `None` if a dependency changed. */
+	const waitChange = (resolution) => Effect.tx(Effect.gen(function* () {
+		const current = yield* TxRef.get(specRef);
+		if (current !== resolution.spec) return Option.some(current);
+		if (resolution.provisions.length === 0 && resolution.unprovided.length === 0) return yield* Effect.txRetry;
+		return (yield* resolutionChanged(resolution)) ? Option.none() : yield* Effect.txRetry;
+	}));
+	const acquire = Effect.gen(function* () {
+		const resolution = yield* Effect.tx(Effect.gen(function* () {
+			const prepared = yield* prepare;
+			const resolution = yield* resolveCurrent(prepared);
+			yield* TxRef.set(processing, resolution.spec);
+			if (resolution.missing.length === 0) {
+				for (const provision of resolution.provisions) yield* TxRef.update(provision.consumers, HashSet.add(id));
+				yield* TxRef.update(node.state, (state) => ({
+					...state,
+					resolution: {
+						watch: resolution.watch,
+						provisions: resolution.provisions
+					}
+				}));
+			}
+			return resolution;
+		}));
+		if (resolution.missing.length > 0) return Acquired.Missing({ resolution });
+		const scope = yield* Scope.make();
+		const tasks = yield* make$1;
+		const published = yield* TxRef.make(Option.some([]));
+		const activation = {
+			fork: id,
+			node,
+			status,
+			tasks: Option.some(tasks),
+			published,
+			fallback: references,
+			provisionKeys: HashSet.fromIterable(Array.map(resolution.provisions, (provision) => provision.service))
+		};
+		const context = Context.makeUnsafe(new Map([
+			...inherited.mapUnsafe,
+			...resolution.ambient,
+			...Array.map(resolution.provisions, (provision) => [provision.service, provision.value]),
+			[Scope.Scope.key, scope],
+			[Graft.key, {
+				runtime,
+				activation
+			}]
+		]));
+		const spec = resolution.spec;
+		yield* setState(runtime, id, status, ForkState.Loading(), spec);
+		const fiber = yield* Effect.suspend(() => spec.plugin.decode(spec.input)).pipe(Effect.flatMap((config) => spec.plugin.apply(config)), Effect.withSpan(`graft.plugin ${spec.plugin.name}`), inActivation(context, spec), Effect.forkIn(scope));
+		const running = {
+			updateCleanup: yield* Ref.make(Cause.empty),
+			resolution,
+			tasks,
+			activation,
+			scope,
+			context,
+			fiber
+		};
+		return Acquired.Running({ running });
+	});
+	const pending = Effect.fnUntraced(function* (resolution) {
+		yield* setState(runtime, id, status, ForkState.Pending({ missing: resolution.missing }), resolution.spec);
+		yield* Effect.tx(Effect.gen(function* () {
+			if ((yield* TxRef.get(specRef)) !== resolution.spec) return;
+			const next = yield* resolveCurrent(resolution.prepared);
+			if (next.spec === resolution.spec && Equal.equals(next.missing, resolution.missing)) return yield* Effect.txRetry;
+		}));
+		return restart;
+	});
+	/** Runs plugin code with the activation's context, which discharges whatever it requires. */
+	const inActivation = (context, spec) => (effect) => Effect.updateContext(Effect.annotateLogs(effect, {
+		"graft.fork": id,
+		"graft.plugin": spec.plugin.name
+	}), () => context);
+	const run = Effect.fnUntraced(function* (running) {
+		const { resolution } = running;
+		let spec = resolution.spec;
+		const fiber = running.fiber;
+		const first = yield* Effect.raceFirst(Effect.asSome(Fiber.await(fiber)), Effect.as(waitChange(resolution), Option.none()));
+		if (Option.isNone(first)) return restart;
+		const exit = first.value;
+		if (exit._tag === "Failure") return Outcome.Failed({
+			resolution,
+			cause: exit.cause
+		});
+		yield* setState(runtime, id, status, ForkState.Active(), spec);
+		const update = exit.value;
+		while (true) {
+			const next = yield* waitChange({
+				...resolution,
+				spec
+			});
+			if (Option.isNone(next) || update === void 0) return restart;
+			const candidate = next.value;
+			if (candidate.plugin !== spec.plugin || candidate.revision !== spec.revision) return restart;
+			yield* TxRef.set(processing, candidate);
+			const operation = Effect.suspend(() => spec.plugin.decode(candidate.input)).pipe(Effect.flatMap(update), inActivation(running.context, spec));
+			if (!(yield* cancelOnChange(operation, waitChange({
+				...resolution,
+				spec: candidate
+			}), (result, settled, _restore, expectedCancellation) => Effect.gen(function* () {
+				if (Exit.isFailure(result)) {
+					if (!expectedCancellation(result.cause) && (Exit.isFailure(settled) || Cause.hasInterrupts(result.cause))) yield* Ref.update(running.updateCleanup, (cause) => Cause.combine(cause, result.cause));
+					if (!expectedCancellation(result.cause) || Exit.isSuccess(settled) && !settled.value) yield* Effect.logWarning("Updating in place failed; restarting instead", result.cause).pipe(Effect.annotateLogs({
+						"graft.fork": id,
+						"graft.plugin": spec.plugin.name
+					}));
+				}
+				if (Exit.isFailure(settled)) return yield* Effect.failCause(settled.cause);
+				return !settled.value && Exit.isSuccess(result) && result.value;
+			})))) return restart;
+			spec = candidate;
+			yield* setState(runtime, id, status, ForkState.Active(), spec);
+		}
+	});
+	/** Every phase finishes before the immutable result is handed to state or disposal. */
+	const teardown = (running, exit) => Effect.gen(function* () {
+		const closer = yield* Effect.withFiber((self) => Effect.succeed(self.id));
+		yield* Fiber.interrupt(running.fiber);
+		const stopped = yield* Fiber.await(running.fiber);
+		const withdrawn = yield* Effect.exit(withdraw(runtime, running.activation));
+		const tasksClosed = yield* close(running.tasks.scope, exit).pipe(Effect.catchCauseIf(Cause.hasInterruptsOnly, () => Effect.void), Effect.exit);
+		const closed = yield* close(running.scope, exit).pipe(Effect.catchCauseIf(Cause.hasInterruptsOnly, () => Effect.void), Effect.exit);
+		const released = yield* Effect.exit(Effect.tx(Effect.gen(function* () {
+			for (const provision of running.resolution.provisions) yield* TxRef.update(provision.consumers, HashSet.remove(id));
+			yield* TxRef.update(node.state, (state) => ({
+				...state,
+				resolution: void 0
+			}));
+		})));
+		const tasks = yield* Ref.get(running.tasks.failures);
+		const updates = yield* Ref.get(running.updateCleanup);
+		const stoppedCause = Exit.isFailure(stopped) && !interruptedBy(stopped.cause, closer) ? stopped.cause : Cause.empty;
+		const cause = Array.reduce([
+			withdrawn,
+			tasksClosed,
+			closed,
+			released
+		], Cause.combine(Cause.combine(tasks, updates), stoppedCause), (cause, result) => Exit.isFailure(result) ? Cause.combine(cause, result.cause) : cause);
+		if (Exit.isFailure(closed)) yield* Effect.logError("Releasing the plugin's resources failed", closed.cause);
+		yield* reportFailure(`Plugin "${running.resolution.spec.plugin.name}" failed`, stopped);
+		return cause.reasons.length === 0 ? Exit.void : Exit.failCause(cause);
+	}).pipe(Effect.annotateLogs({
+		"graft.fork": id,
+		"graft.plugin": running.resolution.spec.plugin.name
+	}));
+	const waitRetry = Effect.fnUntraced(function* (outcome, previous) {
+		const { spec } = outcome.resolution;
+		yield* Effect.uninterruptible(setState(runtime, id, status, ForkState.Failed({ cause: outcome.cause }), spec).pipe(Effect.andThen(Ref.set(cleanup, Exit.void))));
+		const changed = Effect.asVoid(waitChange(outcome.resolution));
+		const blocked = Array.flatMap(outcome.cause.reasons, (reason) => reason._tag === "Fail" && Schema.is(ServiceConflict)(reason.error) && reason.error.fork === id && (reason.error.reason === "SelfDependency" || reason.error.reason === "DependencyCycle") ? [realmKey(reason.error.realm ?? "", reason.error.service)] : []);
+		if (blocked.length > 0) {
+			yield* Effect.acquireUseRelease(Effect.tx(Effect.forEach(blocked, (key) => retain(runtime, key))), (slots) => {
+				const publishable = Effect.tx(Effect.gen(function* () {
+					if ((yield* TxRef.get(specRef)) !== spec) return;
+					const resolution = yield* resolveCurrent(outcome.resolution.prepared);
+					if (resolution.missing.length > 0) return yield* Effect.txRetry;
+					const candidate = {
+						watch: resolution.watch,
+						provisions: resolution.provisions
+					};
+					for (const slot of slots) if ((yield* TxRef.get(slot.provision))._tag === "Some" || (yield* publicationCycle(node, slot.key, candidate))) return yield* Effect.txRetry;
+				}));
+				return Effect.raceFirst(changed, publishable);
+			}, (slots) => Effect.tx(Effect.forEach(slots, (slot) => release(runtime, slot), { discard: true })));
+			return Option.none();
+		}
+		if (spec.plugin.retry === void 0) {
+			yield* changed;
+			return Option.none();
+		}
+		const schedule = spec.plugin.retry;
+		const operation = Effect.gen(function* () {
+			const step = Option.isSome(previous) && sameAttempt(previous.value.resolution, outcome.resolution) ? previous.value.step : yield* Schedule.toStepWithSleep(schedule);
+			return yield* step(outcome.cause).pipe(Effect.as(Option.some({
+				resolution: outcome.resolution,
+				step
+			})), Pull.catchDone(() => Effect.succeedNone));
+		});
+		return yield* cancelOnChange(operation, changed, (result, settled, restore, expectedCancellation) => Effect.gen(function* () {
+			if (Exit.isFailure(settled)) {
+				if (Exit.isFailure(result) && !expectedCancellation(result.cause)) yield* Ref.set(cleanup, result);
+				return yield* Effect.failCause(settled.cause);
+			}
+			if (Exit.isFailure(result) && (!settled.value || !expectedCancellation(result.cause))) yield* setState(runtime, id, status, ForkState.Failed({ cause: Cause.combine(outcome.cause, result.cause) }), spec);
+			if (settled.value) return Option.none();
+			if (Exit.isSuccess(result) && Option.isSome(result.value)) return result.value;
+			yield* restore(changed);
+			return Option.none();
+		}), (result) => reportFailure("The plugin's retry schedule failed", result).pipe(Effect.annotateLogs({
+			"graft.fork": id,
+			"graft.plugin": spec.plugin.name
+		})));
+	});
+	const cycle = Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		const acquired = yield* acquire;
+		if (acquired._tag === "Missing") return yield* restore(pending(acquired.resolution));
+		const running = acquired.running;
+		const used = yield* Effect.exit(restore(Effect.raceFirst(run(running), FiberSet.join(running.tasks.fibers).pipe(Effect.andThen(Effect.never), Effect.catchCause((cause) => Effect.gen(function* () {
+			const spec = yield* TxRef.get(processing);
+			return Outcome.Failed({
+				resolution: {
+					...running.resolution,
+					spec
+				},
+				cause
+			});
+		}))))));
+		const cleaned = yield* teardown(running, Exit.isSuccess(used) && used.value._tag === "Failed" ? Exit.failCause(used.value.cause) : used);
+		const closed = Exit.isSuccess(used) && used.value._tag === "Failed" && Cause.hasInterruptsOnly(used.value.cause) && Exit.isFailure(cleaned) ? Exit.failCause(Cause.combine(used.value.cause, cleaned.cause)) : cleaned;
+		yield* Ref.set(cleanup, closed);
+		if (Exit.isFailure(used)) return yield* Effect.failCause(used.cause);
+		if (Exit.isFailure(closed)) {
+			const spec = yield* TxRef.get(processing);
+			return Outcome.Failed({
+				resolution: {
+					...running.resolution,
+					spec
+				},
+				cause: closed.cause
+			});
+		}
+		return used.value;
+	}));
+	const loop = (previous) => cycle.pipe(Effect.flatMap((outcome) => outcome._tag === "Failed" ? waitRetry(outcome, previous) : Effect.succeedNone), Effect.flatMap(loop));
+	yield* loop(Option.none()).pipe(Effect.ensuring(Effect.tx(Effect.gen(function* () {
+		const remaining = yield* TxRef.get(held);
+		if (remaining === void 0) return;
+		for (const slot of HashMap.values(remaining.slots)) yield* release(runtime, slot);
+	}))));
+});
+// packages/core/src/Graft.ts
+/**
+* The graft runtime: loading plugins, publishing services, replacing
+* plugins at runtime, and observing the fork tree and its logs.
+*/
+/**
+* The graft a piece of code runs in: the shared runtime plus the activation
+* that owns anything it publishes.
+*/
+var Graft = class extends Context.Service()("@graftland/graft/Graft") {};
+var ServiceConflict = class extends Schema.TaggedError()("ServiceConflict", {
+	service: Schema.String,
+	/** Absent for an existing provision; otherwise explains why this activation cannot publish. */
+	reason: Schema.optionalKey(Schema.Literals([
+		"SelfDependency",
+		"DependencyCycle",
+		"Invalidated"
+	])),
+	realm: Schema.optionalKey(Schema.String),
+	fork: Schema.optionalKey(Schema.Finite)
+}) {
+	get message() {
+		return this.reason === void 0 ? `Service "${this.service}" is already provided in this realm` : this.reason === "Invalidated" ? `Cannot provide "${this.service}": the provider's dependencies have changed` : `Cannot provide "${this.service}": publication would restart its own provider`;
+	}
+};
+/**
+* Publishes a service into the current realm. It stays available until the
+* activation that published it is torn down, which first waits for every
+* consumer to let go of it.
+*/
+const provide = Effect.fnUntraced(function* (key, value) {
+	const { runtime, activation } = yield* Graft;
+	const realms = yield* Realms;
+	const qualified = realmKey(realmOf(realms, key.key), key.key);
+	yield* Effect.tx(Effect.gen(function* () {
+		const published = yield* TxRef.get(activation.published);
+		if (Option.isNone(published)) return yield* Effect.die(/* @__PURE__ */ new Error(`Cannot provide "${key.key}": the plugin providing it is being torn down`));
+		const { resolution } = yield* TxRef.get(activation.node.state);
+		if (resolution !== void 0 && (yield* resolutionChanged(resolution))) return yield* ServiceConflict.make({
+			service: key.key,
+			reason: "Invalidated"
+		});
+		const directory = yield* TxRef.get(runtime.slots);
+		const existing = HashMap.get(directory, qualified);
+		if (Option.isSome(existing) && (yield* TxRef.get(existing.value.provision))._tag === "Some") return yield* ServiceConflict.make({ service: key.key });
+		if (yield* publicationCycle(activation.node, qualified)) {
+			const direct = resolution !== void 0 && HashMap.has(resolution.watch, qualified);
+			return yield* ServiceConflict.make({
+				service: key.key,
+				realm: realmOf(realms, key.key),
+				fork: activation.fork,
+				reason: direct ? "SelfDependency" : "DependencyCycle"
+			});
+		}
+		const slot = yield* retain(runtime, qualified);
+		const provision = {
+			key: qualified,
+			service: key.key,
+			value,
+			owner: activation.fork,
+			node: activation.node,
+			slot,
+			consumers: TxRef.makeUnsafe(HashSet.empty())
+		};
+		yield* TxRef.set(slot.provision, Option.some(provision));
+		yield* TxRef.set(activation.published, Option.some(Array.append(published.value, provision)));
+	}));
+});
+/** How many log entries new subscribers of `logs` receive from the past. */
+const logReplay = 1e3;
+const runtimeLayer = Layer.effect(Graft, Effect.gen(function* () {
+	const ambient = yield* Effect.context();
+	const runtime = {
+		ambient,
+		slots: yield* TxRef.make(HashMap.empty()),
+		forks: yield* TxSubscriptionRef.make(HashMap.empty()),
+		aliases: make$3(),
+		events: yield* TxRef.make(HashMap.empty()),
+		ids: yield* TxRef.make(1),
+		logs: yield* PubSub.sliding({
+			capacity: logReplay,
+			replay: logReplay
+		})
+	};
+	const published = yield* TxRef.make(Option.some([]));
+	const activation = {
+		fork: 0,
+		node: {
+			id: 0,
+			parent: void 0,
+			state: TxRef.makeUnsafe({
+				live: true,
+				resolution: void 0
+			})
+		},
+		status: void 0,
+		tasks: Option.none(),
+		published,
+		provisionKeys: HashSet.empty(),
+		fallback: ambient
+	};
+	yield* Effect.addFinalizer(() => withdraw(runtime, activation));
+	return {
+		runtime,
+		activation
+	};
+}));
+/** Copies every log entry into the runtime, so `logs` can replay recent history. */
+const loggerLayer = Logger.layer([Effect.map(Graft, ({ runtime }) => Logger.make((options) => {
+	PubSub.publishUnsafe(runtime.logs, {
+		date: options.date,
+		level: options.logLevel,
+		message: options.message,
+		cause: options.cause,
+		annotations: options.fiber.getRef(References.CurrentLogAnnotations)
+	});
+}))], { mergeWithExisting: true });
+/** The root graft. Services provided at the root are withdrawn when the layer closes. */
+const layer = Layer.provideMerge(loggerLayer, runtimeLayer);
+const intercept = (reference, f) => ({ apply: (effect) => Effect.updateService(effect, reference, f) });
+const isolation = (id) => (entry) => "key" in entry ? [entry.key, `#${id}`] : [entry[0].key, `@${entry[1]}`];
+/**
+* Changes a fork's spec and waits until its supervisor has acted on it:
+* updated in place, or begun restarting. A later change also counts.
+*/
+const accept = (status, spec, f) => Effect.gen(function* () {
+	const next = yield* TxRef.modify(spec, (current) => {
+		const next = f(current);
+		return [next, next];
+	});
+	yield* Effect.tx(Effect.gen(function* () {
+		const snapshot = yield* TxSubscriptionRef.get(status.snapshot);
+		if (snapshot.disposed || snapshot.accepted === next) return;
+		if ((yield* TxRef.get(spec)) !== next) return;
+		return yield* Effect.txRetry;
+	}));
+});
+const makeFork = (status, id, spec, dispose) => {
+	const state = TxSubscriptionRef.changesStream(status.snapshot).pipe(Stream.map((snapshot) => snapshot.state), Stream.changes, Stream.takeUntil(ForkState.$is("Disposed")));
+	return {
+		id,
+		state,
+		await: state.pipe(Stream.filter((state) => !ForkState.$is("Loading")(state)), Stream.runHead, Effect.flatMap((state) => Option.isSome(state) && state.value._tag === "Failed" ? Effect.failCause(state.value.cause) : Effect.void)),
+		stable: stable(status),
+		update: (input) => accept(status, spec, (current) => ({
+			...current,
+			input
+		})),
+		restart: accept(status, spec, (current) => ({
+			...current,
+			revision: current.revision + 1
+		})),
+		dispose
+	};
+};
+/** Loads a plugin under the current scope. Closing that scope unloads it. */
+const plugin = Effect.fnUntraced(function* (plugin, input, options) {
+	return yield* Effect.uninterruptible(Effect.gen(function* () {
+		const { runtime, activation } = yield* Graft;
+		const scope = yield* Effect.scope;
+		const termination = yield* Ref.make(Exit.void);
+		const owned = yield* ownedScope(scope, Effect.flatMap(Ref.get(termination), (exit) => Exit.isFailure(exit) ? Effect.fail(CleanupError.make({ cause: exit.cause })) : Effect.void));
+		const forkScope = owned.scope;
+		const { id, spec, node, status } = yield* Effect.acquireRelease(Effect.tx(Effect.gen(function* () {
+			const id = yield* TxRef.get(runtime.ids);
+			yield* TxRef.set(runtime.ids, id + 1);
+			const resolved = yield* resolve$1(runtime.aliases, plugin);
+			const spec = TxRef.makeUnsafe({
+				plugin: resolved,
+				input,
+				revision: 0
+			});
+			const node = {
+				id,
+				parent: activation.node.id === 0 ? void 0 : activation.node,
+				state: TxRef.makeUnsafe({
+					live: true,
+					resolution: void 0
+				})
+			};
+			const initialSpec = yield* TxRef.get(spec);
+			const status = yield* make$2(activation.status, initialSpec);
+			const entry = {
+				id,
+				node,
+				status,
+				parent: activation.fork === 0 ? void 0 : activation.fork,
+				spec,
+				accepted: void 0,
+				name: resolved.name,
+				input,
+				state: ForkState.Loading()
+			};
+			yield* TxSubscriptionRef.update(runtime.forks, HashMap.set(id, entry));
+			return {
+				id,
+				spec,
+				node,
+				status
+			};
+		})), ({ id, node, status }) => Effect.tx(Effect.gen(function* () {
+			yield* TxRef.set(node.state, {
+				live: false,
+				resolution: void 0
+			});
+			yield* dispose(runtime, id, status);
+		}))).pipe(Scope.provide(forkScope));
+		const realms = HashMap.fromIterable(Array.map(options?.isolate ?? [], isolation(id)));
+		const inherited = yield* Effect.context();
+		const context = inheritContext(activation, inherited);
+		const supervisor = Effect.forever(Effect.gen(function* () {
+			const initial = yield* TxRef.get(spec);
+			const processing = yield* TxRef.make(initial);
+			yield* Effect.suspend(() => Array.reduce(options?.intercept ?? [], supervise(runtime, id, spec, processing, node, status, termination).pipe(Effect.updateService(Realms, (outer) => HashMap.union(outer, realms))), (effect, entry) => entry.apply(effect))).pipe(Effect.andThen(Effect.die(/* @__PURE__ */ new Error("The plugin supervisor stopped unexpectedly"))), Effect.catchCause((cause) => Effect.gen(function* () {
+				if (forkScope.state._tag === "Closed") return yield* Effect.failCause(cause);
+				const cleanup = yield* Ref.get(termination);
+				const completeCause = Exit.isFailure(cleanup) ? Cause.combine(cause, cleanup.cause) : cause;
+				const attempted = yield* TxRef.get(processing);
+				yield* Effect.logError("The plugin supervisor failed", cause).pipe(Effect.annotateLogs({
+					"graft.fork": id,
+					"graft.plugin": attempted.plugin.name
+				}));
+				yield* Effect.uninterruptible(setState(runtime, id, status, ForkState.Failed({ cause: completeCause }), attempted).pipe(Effect.andThen(Ref.set(termination, Exit.void))));
+				yield* Effect.tx(Effect.gen(function* () {
+					if ((yield* TxRef.get(spec)) === attempted) return yield* Effect.txRetry;
+				}));
+			})));
+		})).pipe(Effect.updateContext(() => context));
+		yield* Effect.acquireRelease(Effect.forkIn(supervisor, forkScope), (fiber) => Effect.gen(function* () {
+			const closer = yield* Effect.withFiber((self) => Effect.succeed(self.id));
+			yield* Fiber.interrupt(fiber);
+			const exit = yield* Fiber.await(fiber);
+			return yield* Exit.isFailure(exit) && !Array.every(exit.cause.reasons, (reason) => reason._tag === "Interrupt" && reason.fiberId === closer) ? Ref.update(termination, (cleanup) => Exit.failCause(Exit.isFailure(cleanup) ? Cause.combine(cleanup.cause, exit.cause) : exit.cause)).pipe(Effect.andThen(Effect.logError("Stopping the plugin supervisor failed", exit.cause).pipe(Effect.annotateLogs({ "graft.fork": id })))) : Effect.void;
+		})).pipe(Scope.provide(forkScope));
+		return makeFork(status, id, spec, owned.close(Exit.void));
+	}));
+});
+/** The requested identities cannot be represented by the runtime's flat aliases. */
+var ReplacementConflict = class extends Schema.TaggedError()("ReplacementConflict", { indices: Schema.Array(Schema.Int) }) {};
+Effect.fnUntraced(function* (pairs) {
+	const { runtime } = yield* Graft;
+	yield* Effect.tx(Effect.gen(function* () {
+		const conflicts = yield* replace$1(runtime.aliases, pairs);
+		if (conflicts.length > 0) return yield* ReplacementConflict.make({ indices: conflicts });
+		const forks = yield* TxSubscriptionRef.get(runtime.forks);
+		for (const entry of HashMap.values(forks)) {
+			const spec = yield* TxRef.get(entry.spec);
+			const next = yield* resolve$1(runtime.aliases, spec.plugin);
+			if (next !== spec.plugin) yield* TxRef.set(entry.spec, {
+				...spec,
+				plugin: next,
+				revision: spec.revision + 1
+			});
+		}
+	}));
+});
+const byId = Order.mapInput(Order.Number, (entry) => entry.id);
+const buildTree = (forks) => {
+	const key = (parent) => parent === void 0 ? "" : `${parent}`;
+	const byParent = Array.groupBy(Array.sort(HashMap.toValues(forks), byId), (entry) => key(entry.parent));
+	const children = (parent) => Array.map(Record.get(byParent, key(parent)).pipe(Option.getOrElse(() => [])), (entry) => ({
+		id: entry.id,
+		name: entry.name,
+		input: entry.input,
+		state: entry.state,
+		children: children(entry.id)
+	}));
+	return children(void 0);
+};
+/** The fork tree, emitted again on every change. */
+const forks = Stream.unwrap(Effect.map(Graft, ({ runtime }) => TxSubscriptionRef.changesStream(runtime.forks).pipe(Stream.map(buildTree))));
+Stream.unwrap(Effect.map(Graft, ({ runtime }) => Stream.fromPubSub(runtime.logs)));
+export { provide as a, isPlugin as c, service as d, CleanupError as f, plugin as i, make as l, intercept as n, fork as o, layer as r, fromModule as s, forks as t, optional as u };