@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/cli-runtime.layer-BqK2mmVL.mjs

@@ -0,0 +1,1191 @@
+import { On as pipeArguments, Sn as identity, d as fromUndefinedOr, dn as isUndefined, en as isNotNull, nn as isNotUndefined, rn as isNullish, vn as constVoid, x as match } from "./Option-DkxSnBhp.mjs";
+import { $t as suspend, A as ensuring, At as provideContext, B as flatMap, Br as done, C as catch_, Dr as isFailure, F as failSync, Fn as catchDone, Gn as mergeAll, Gt as scoped, Jn as succeed$2, K as forEach, Lr as UnknownError, M as fail$1, Mr as void_, Nr as Done, Nt as raceFirst, Or as isSuccess, Qn as close, Rn as isDoneCause, St as onExit, Vn as effect, W as fnUntraced, Wt as scope, X as forkScoped, Xn as addFinalizer, Xt as succeed, Yn as Scope, Yt as sleep, Zn as addFinalizerExit, ca as get$2, dt as map, en as sync, et as gen, fn as uninterruptible, gn as void_$1, gr as makeUnsafe$1, ht as mapError, i as addFinalizer$1, jr as succeed$1, l as as, ln as try_, lr as doneUnsafe, mr as isDoneUnsafe, n as acquireRelease, nt as ignoreCause, o as andThen, oa as add, p as callback, pn as uninterruptibleMask, pr as isDone, q as forever, qn as provideMerge, rr as makeUnsafe, rt as interrupt, sr as _await, tt as ignore, ur as fail$2, xr as fail, xt as onError, yn as withFiber, zt as runForkWith } from "./Effect-CKFpqbmw.mjs";
+import { F as of } from "./Array-B4kuTQeW.mjs";
+import { a as isFinite, m as toMillis, n as fromInputUnsafe } from "./Duration-EH9Vy4U6.mjs";
+import { A as merge, J as suspend$1, Z as tapError, _ as fromChannel, at as mapDone, bt as runIn, f as fail$3, ft as makeUnsafe$2, gt as interrupt$1, ht as getCurrent, it as fromTransform, l as empty, nt as unwrap$1, tt as transduce, w as isStream, yt as join, z as run } from "./Stream-bK9QIETN.mjs";
+import { c as make$4, d as offerUnsafe, f as poll, g as take, h as sliding, i as endUnsafe } from "./Queue-CO5UQ6os.mjs";
+import { n as layerWebCrypto } from "./SecureRandom-B_U4ysO3.mjs";
+import { c as handleErrnoException, o as layer$7, s as layer$6 } from "./hosted-runtime.layer-Cx3IPsEd.mjs";
+import { a as drain, l as badArgument, o as fromChannel$1, s as isSink, t as FileSystem, u as systemError } from "./FileSystem-4pPcEb_i.mjs";
+import { n as layerWebCrypto$1 } from "./Digest-CBd3uv5B.mjs";
+import { i as value, t as isRedacted } from "./Redacted-RkJrG5Me.mjs";
+import { a as ChildProcessSpawner, c as make$6, i as display, l as makeHandle, n as make$5, o as ExitCode, r as parseFdName, s as ProcessId, t as fdName } from "./ChildProcess-BCIwxPGc.mjs";
+import { t as make$7 } from "./MutableRef-D4Qv592C.mjs";
+import { t as Path } from "./Path-Djdv_eF5.mjs";
+import { n as make$8, t as Stdio } from "./Stdio-KylmOBX_.mjs";
+import { S as Terminal, w as make$9, x as QuitError } from "./TerminalCapabilities-w_44MAca.mjs";
+import { r as layer$8 } from "./cloud-client.adapter-DOVMoYAj.mjs";
+import { AkterArchive } from "./archive/akter-archive.service.mjs";
+import { Bench } from "./bench/bench.service.mjs";
+import { Deployment } from "./deploy/deploy.service.mjs";
+import { ActorExport } from "./export/actor-export.service.mjs";
+import { t as ActorCall } from "./actor-call.service-CGM_vD9u.mjs";
+import { OperationCall } from "./registry/operation-call.service.mjs";
+import * as NodeChildProcess from "node:child_process";
+import { PassThrough, finished } from "node:stream";
+import * as readline from "node:readline";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/rcRef.js
+const TypeId = "~effect/RcRef";
+const stateEmpty = { _tag: "Empty" };
+const stateClosed = { _tag: "Closed" };
+const variance = {
+	_A: identity,
+	_E: identity
+};
+var RcRefImpl = class {
+	[TypeId] = variance;
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+	state = stateEmpty;
+	acquire;
+	context;
+	scope;
+	idleTimeToLive;
+	constructor(acquire, context, scope, idleTimeToLive) {
+		this.acquire = acquire;
+		this.context = context;
+		this.scope = scope;
+		this.idleTimeToLive = idleTimeToLive;
+	}
+};
+/** @internal */
+const make$3 = (options) => withFiber((fiber) => {
+	const context = fiber.context;
+	const scope = get$2(context, Scope);
+	const ref = new RcRefImpl(options.acquire, context, scope, options.idleTimeToLive !== void 0 ? fromInputUnsafe(options.idleTimeToLive) : void 0);
+	return as(addFinalizerExit(scope, () => {
+		const state = ref.state;
+		ref.state = stateClosed;
+		if (state._tag === "Acquired") return close(state.scope, void_);
+		if (state._tag === "Acquiring") return interrupt$1(state.fiber);
+		return void_$1;
+	}), ref);
+});
+const getState = (self, restore) => {
+	switch (self.state._tag) {
+		case "Closed": return interrupt;
+		case "Acquired": {
+			const state = self.state;
+			state.refCount++;
+			return state.fiber ? as(interrupt$1(state.fiber), state) : succeed(state);
+		}
+		case "Acquiring": {
+			const state = self.state;
+			state.awaiters++;
+			return awaitAcquiring(self, state, restore);
+		}
+		case "Empty": {
+			const acquiring = {
+				_tag: "Acquiring",
+				fiber: void 0,
+				awaiters: 1,
+				acquired: void 0
+			};
+			self.state = acquiring;
+			const scope = makeUnsafe();
+			const acquire = provideContext(self.acquire, add(self.context, Scope, scope)).pipe(flatMap((value) => {
+				if (self.state !== acquiring) return interrupt;
+				const state = {
+					_tag: "Acquired",
+					value,
+					scope,
+					fiber: void 0,
+					refCount: acquiring.awaiters,
+					invalidated: false
+				};
+				self.state = state;
+				acquiring.acquired = state;
+				return succeed(state);
+			}), onExit((exit) => {
+				if (isSuccess(exit)) return void_$1;
+				if (self.state === acquiring) self.state = stateEmpty;
+				return close(scope, exit);
+			}));
+			acquiring.fiber = runForkWith(getCurrent().context)(acquire);
+			return awaitAcquiring(self, acquiring, restore);
+		}
+	}
+};
+const awaitAcquiring = (self, acquiring, restore) => onExit(restore(join(acquiring.fiber)), (exit) => {
+	const acquired = acquiring.acquired;
+	if (acquired !== void 0) return isFailure(exit) ? release(self, acquired) : void_$1;
+	if (--acquiring.awaiters > 0 || self.state !== acquiring) return void_$1;
+	self.state = stateEmpty;
+	return interrupt$1(acquiring.fiber);
+});
+/** @internal */
+const get$1 = (self_) => {
+	const self = self_;
+	return uninterruptibleMask((restore) => flatMap(scope, (scope) => flatMap(getState(self, restore), (state) => as(addFinalizerExit(scope, () => release(self, state)), state.value))));
+};
+const release = (self, state) => {
+	state.refCount--;
+	if (state.refCount > 0) return void_$1;
+	const idleTimeToLive = self.idleTimeToLive;
+	if (idleTimeToLive === void 0 || state.invalidated) {
+		if (self.state === state) self.state = stateEmpty;
+		return close(state.scope, void_);
+	} else if (!isFinite(idleTimeToLive)) return void_$1;
+	state.fiber = uninterruptibleMask((restore) => flatMap(restore(sleep(idleTimeToLive)), () => {
+		if (self.state === state && state.refCount === 0) {
+			self.state = stateEmpty;
+			return ignoreCause(close(state.scope, void_), {
+				log: "Unhandled",
+				message: "Unhandled error in RcRef finalizer"
+			});
+		}
+		return void_$1;
+	})).pipe(ensuring(sync(() => {
+		state.fiber = void 0;
+	})), runForkWith(self.context), runIn(self.scope));
+	return void_$1;
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/RcRef.js
+/**
+* Creates an `RcRef` from an acquire effect.
+*
+* **When to use**
+*
+* Use to create a lazily acquired, reference-counted resource from an acquire
+* effect.
+*
+* **Details**
+*
+* The resource is acquired lazily on the first `get` and shared by subsequent
+* gets while it remains cached. Each `get` adds a reference to the current
+* `Scope`. When the last reference is released, the resource is closed
+* immediately by default, or after `idleTimeToLive` when that option is
+* provided.
+*
+* **Example** (Creating a reference-counted resource)
+*
+* ```ts import.meta.vitest
+* import { Effect, RcRef } from "effect"
+*
+* const events: Array<string> = []
+*
+* const program = Effect.gen(function*() {
+*   const ref = yield* RcRef.make({
+*     acquire: Effect.acquireRelease(
+*       Effect.succeed("foo"),
+*       () => Effect.sync(() => events.push("released foo"))
+*     )
+*   })
+*
+*   // will only acquire the resource once, and release it
+*   // when the scope is closed
+*   yield* RcRef.get(ref).pipe(
+*     Effect.andThen(RcRef.get(ref)),
+*     Effect.scoped
+*   )
+* })
+*
+* await Effect.runPromise(Effect.scoped(program))
+* events // => ["released foo"]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 3.5.0
+*/
+const make$2 = make$3;
+/**
+* Gets the value from an `RcRef`, acquiring it first if needed.
+*
+* **When to use**
+*
+* Use to borrow the current resource within a `Scope`, acquiring it first if
+* necessary.
+*
+* **Details**
+*
+* The reference count is incremented for the current `Scope`, and a release
+* finalizer is added to that scope. When the current scope closes, the
+* reference is released; the resource is closed when the final reference is
+* released, subject to any configured idle time-to-live.
+*
+* **Example** (Sharing one acquired value)
+*
+* ```ts import.meta.vitest
+* import { Effect, RcRef } from "effect"
+*
+* const events: Array<string> = []
+*
+* const program = Effect.gen(function*() {
+*   // Create an RcRef with a resource
+*   const ref = yield* RcRef.make({
+*     acquire: Effect.acquireRelease(
+*       Effect.succeed("shared resource"),
+*       (resource) => Effect.sync(() => events.push(`released ${resource}`))
+*     )
+*   })
+*
+*   // Get the value from the RcRef
+*   const value1 = yield* RcRef.get(ref)
+*   const value2 = yield* RcRef.get(ref)
+*
+*   return [value1 === value2, events] as const
+* })
+*
+* await Effect.runPromise(Effect.scoped(program)) // => [true, ["released shared resource"]]
+* ```
+*
+* @stability stable
+* @category combinators
+* @since 3.5.0
+*/
+const get = get$1;
+// ../../node_modules/.pnpm/@effect+platform-node-shared@4.1.2_effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488_9ec8b663d83a20b2301217607fca650e/node_modules/@effect/platform-node-shared/dist/internal/nodeChildProcessSpawner.js
+const buildSpawnOptions = (options, base, platform) => {
+	const detached = options.detached ?? platform !== "win32";
+	return {
+		...base,
+		detached,
+		shell: options.shell,
+		windowsHide: options.windowsHide ?? !detached
+	};
+};
+// ../../node_modules/.pnpm/@effect+platform-node-shared@4.1.2_effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488_9ec8b663d83a20b2301217607fca650e/node_modules/@effect/platform-node-shared/dist/internal/stream.js
+const destroyStream = (stream, cleanup, onDestroyed) => {
+	if (!("closed" in stream)) {
+		cleanup();
+		onDestroyed?.();
+		return;
+	}
+	const onDone = () => {
+		clearImmediate(immediate);
+		stream.off("error", onDone);
+		stream.off("close", onDone);
+		onDestroyed?.();
+	};
+	const onClosed = () => {
+		if (stream.closed) onDone();
+		else {
+			immediate = setImmediate(onClosed);
+			if (!onDestroyed) immediate.unref();
+		}
+	};
+	let immediate = setImmediate(onClosed);
+	if (!onDestroyed) immediate.unref();
+	stream.once("error", onDone);
+	stream.once("close", onDone);
+	cleanup();
+	if (!stream.closed) stream.destroy();
+};
+// ../../node_modules/.pnpm/@effect+platform-node-shared@4.1.2_effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488_9ec8b663d83a20b2301217607fca650e/node_modules/@effect/platform-node-shared/dist/NodeSink.js
+/**
+* Creates a `Sink` that writes chunks to a Node writable stream, respecting
+* backpressure and mapping writable errors with `onError`. Unless `endOnDone`
+* is `false`, the writable is ended on completion and destroyed on upstream
+* failure or interruption.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const fromWritable = (options) => fromChannel$1(mapDone(fromWritableChannel(options), (_) => [_]));
+/**
+* Creates a `Channel` that pulls chunks from upstream and writes them to a
+* Node writable stream, respecting backpressure. Unless `endOnDone` is
+* `false`, the writable is ended when upstream is done and destroyed on
+* upstream failure or interruption.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const fromWritableChannel = (options) => fromTransform((pull) => {
+	const writable = options.evaluate();
+	const write = pullIntoWritable({
+		...options,
+		writable,
+		pull
+	});
+	return succeed(options.endOnDone === false ? write : onError(write, (cause) => isDoneCause(cause) ? void_$1 : releaseWritable(writable)));
+});
+const releaseWritable = (writable) => callback((resume) => {
+	const onDestroyed = () => resume(void_$1);
+	if (writable.closed) {
+		const cleanup = finished(writable, { readable: false }, () => {
+			cleanup();
+			onDestroyed();
+		});
+	} else destroyStream(writable, constVoid, onDestroyed);
+});
+/**
+* Writes Effect chunks into a Node writable stream.
+*
+* **When to use**
+*
+* Use to implement custom Node stream adapters that already have an upstream
+* pull and need direct control over a writable stream.
+*
+* **Details**
+*
+* The loop waits for `drain` when needed, fails on writable errors, and ends
+* the writable on upstream completion unless `endOnDone` is `false`.
+*
+* @stability unstable
+* @category converting
+* @since 4.0.0
+*/
+const pullIntoWritable = (options) => withFiber((fiber) => {
+	const dispatcher = fiber.currentDispatcher;
+	const completion = makeUnsafe$1();
+	const failure = makeUnsafe$1();
+	const onError = (error) => doneUnsafe(failure, failSync(() => options.onError(error)));
+	let errorEmitted = false;
+	const onStreamError = (error) => {
+		errorEmitted = true;
+		onError(error);
+	};
+	options.writable.on("error", onStreamError);
+	const cleanup = finished(options.writable, { readable: false }, (error) => {
+		if (error) onError(error);
+		else doneUnsafe(completion, void_$1);
+	});
+	return options.pull.pipe(flatMap((chunk) => {
+		let i = 0;
+		return callback((resume) => {
+			let cancelled = false;
+			const onFinish = () => dispatcher.scheduleTask(loop, 0);
+			const loop = () => {
+				options.writable.off("drain", loop);
+				options.writable.off("finish", onFinish);
+				for (; i < chunk.length;) {
+					if (cancelled) return;
+					if (!options.writable.write(chunk[i++], options.encoding, (error) => {
+						if (!error) return;
+						if (options.writable.closed) onError(error);
+						else dispatcher.scheduleTask(() => onError(error), 0);
+					})) {
+						if (!cancelled) {
+							options.writable.once("drain", loop);
+							options.writable.once("finish", onFinish);
+						}
+						return;
+					}
+				}
+				if (!cancelled) resume(void_$1);
+			};
+			loop();
+			return sync(() => {
+				cancelled = true;
+				options.writable.off("drain", loop);
+				options.writable.off("finish", onFinish);
+			});
+		});
+	}), forever({ disableYield: true }), options.endOnDone !== false ? catchDone((_) => {
+		options.writable.end();
+		return andThen(_await(completion), done(_));
+	}) : identity, raceFirst(_await(failure)), ensuring(sync(() => {
+		cleanup();
+		const removeErrorListener = () => {
+			options.writable.off("error", onStreamError);
+			options.writable.off("error", removeErrorListener);
+			options.writable.off("close", removeErrorListener);
+		};
+		if (options.writable.errored && !options.writable.closed && !errorEmitted) {
+			options.writable.once("error", removeErrorListener);
+			options.writable.once("close", removeErrorListener);
+		} else removeErrorListener();
+	})));
+});
+// ../../node_modules/.pnpm/@effect+platform-node-shared@4.1.2_effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488_9ec8b663d83a20b2301217607fca650e/node_modules/@effect/platform-node-shared/dist/NodeStream.js
+/**
+* Adapters between Node streams and Effect streams, channels, and readables.
+*
+* This module is the stream boundary for Node APIs. It wraps `Readable` and
+* `Duplex` values as Effect `Stream`s and `Channel`s, pipes Effect streams
+* through Node duplex streams, exposes an Effect `Stream` back to Node as a
+* `Readable`, and collects readable payloads into strings, array buffers, or
+* `Uint8Array`s with optional byte limits.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
+* Converts a Node readable stream into an Effect `Stream`, reading chunks with
+* independent read sizes and batch limits, mapping stream errors with `onError`,
+* and destroying the readable on completion unless `closeOnDone` is `false`.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const fromReadable = (options) => fromChannel(fromReadableChannel(options));
+/**
+* Creates a `Channel` that pulls chunks from a Node readable stream, mapping
+* errors with `onError` and destroying the readable on completion unless
+* `closeOnDone` is `false`.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const fromReadableChannel = (options) => fromTransform((_, scope) => readableToPullUnsafe({
+	scope,
+	readable: options.evaluate(),
+	onError: options.onError ?? defaultOnError,
+	chunkSize: options.chunkSize,
+	readSize: options.readSize,
+	closeOnDone: options.closeOnDone
+}));
+const readableToPullUnsafe = (options) => {
+	const readable = options.readable;
+	const chunkSize = options.chunkSize ?? 4096;
+	const closeOnDone = options.closeOnDone ?? true;
+	const exit = options.exit ?? make$7(void 0);
+	const latch = options.latch ?? makeUnsafe$2(false);
+	function onReadable() {
+		latch.openUnsafe();
+	}
+	readable.on("readable", onReadable);
+	const cleanup = finished(readable, {
+		readable: true,
+		writable: false
+	}, (error) => {
+		exit.current ??= fail(error ? options.onError(error) : Done());
+		latch.openUnsafe();
+	});
+	const pull = suspend(function loop() {
+		let item = options.readable.read(options.readSize);
+		if (item === null) {
+			if (exit.current) return exit.current;
+			if (readable.readableEnded) return fail$1(Done());
+			latch.closeUnsafe();
+			return flatMap(latch.await, loop);
+		}
+		const chunk = of(item);
+		while (chunk.length < chunkSize) {
+			item = options.readable.read(options.readSize);
+			if (item === null) break;
+			chunk.push(item);
+		}
+		return succeed(chunk);
+	});
+	return as(addFinalizer(options.scope, sync(() => {
+		readable.off("readable", onReadable);
+		if (closeOnDone) destroyStream(readable, cleanup);
+		else cleanup();
+	})), pull);
+};
+const defaultOnError = (error) => new UnknownError(error);
+// ../../node_modules/.pnpm/@effect+platform-node-shared@4.1.2_effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488_9ec8b663d83a20b2301217607fca650e/node_modules/@effect/platform-node-shared/dist/NodeChildProcessSpawner.js
+const toError = (error) => error instanceof globalThis.Error ? error : new globalThis.Error(String(error));
+const toPlatformError = (method, error, command) => {
+	const { commands } = flattenCommand(command);
+	const format = globalThis.process.platform === "win32" ? "windows" : "posix";
+	const commandStr = commands.map((cmd) => display([cmd.command, ...cmd.args], { format })).join(" | ");
+	return handleErrnoException("ChildProcess", method)(error, [commandStr]);
+};
+const unwrap = (value$1) => isRedacted(value$1) ? value(value$1) : value$1;
+const findNulCharacter = (command) => {
+	if (command.command.includes("\0")) return "The command contains a NUL character";
+	const index = command.args.findIndex((arg) => unwrap(arg).includes("\0"));
+	if (index !== -1) return `Argument ${index + 1} contains a NUL character`;
+	for (const [name, value] of Object.entries(command.options.env ?? {})) if (value !== void 0 && unwrap(value).includes("\0")) return `The environment variable ${name} contains a NUL character`;
+};
+const processGroupGraceMillis = 1e3;
+const processGroupPollIntervalMillis = 10;
+const handleInputErrors = (writable) => {
+	const onError = () => {};
+	writable.on("error", onError);
+	writable.once("close", () => writable.off("error", onError));
+};
+/** Node has recorded the leader's exit, after which its PID may be reused by an unrelated process. */
+const hasExited = (childProcess) => childProcess.exitCode !== null || childProcess.signalCode !== null;
+/**
+* A non-detached leader shares its parent's process group, so once it has
+* exited there is no group of its own left to signal or poll.
+*/
+const ownsProcessGroup = (command, childProcess) => command.options.detached !== false || !hasExited(childProcess);
+/**
+* The process group exists but has no member that can be signalled, such as
+* on macOS when its remaining members are zombies.
+*/
+const isUnsignallableProcessGroup = (error) => error?.code === "EPERM";
+/** The leader has not exited, or a member of its process group still exists. */
+const isProcessAlive = (command, childProcess) => {
+	if (!hasExited(childProcess)) return true;
+	if (globalThis.process.platform === "win32" || !ownsProcessGroup(command, childProcess)) return false;
+	try {
+		globalThis.process.kill(-childProcess.pid, 0);
+		return true;
+	} catch (error) {
+		return isUnsignallableProcessGroup(error);
+	}
+};
+const taskkill = (childProcess, onExit = () => {}) => {
+	if (hasExited(childProcess)) {
+		onExit(null);
+		return;
+	}
+	NodeChildProcess.execFile("taskkill", [
+		"/pid",
+		String(childProcess.pid),
+		"/T",
+		"/F"
+	], { windowsHide: true }, onExit);
+};
+/**
+* Layer that provides the `NodeChildProcessSpawner` implementation.
+*
+* @stability unstable
+* @category layers
+* @since 4.0.0
+*/
+const layer$5 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(function* () {
+	const fs = yield* FileSystem;
+	const path = yield* Path;
+	const resolveWorkingDirectory = fnUntraced(function* (options) {
+		if (isUndefined(options.cwd)) return void 0;
+		yield* fs.access(options.cwd);
+		return path.resolve(options.cwd);
+	});
+	const resolveEnvironment = (options) => {
+		if (options.env === void 0) return void 0;
+		const env = options.extendEnv === true ? { ...globalThis.process.env } : {};
+		for (const [key, value] of Object.entries(options.env)) if (value === void 0) delete env[key];
+		else env[key] = unwrap(value);
+		return env;
+	};
+	const inputToStdioOption = (input) => isStream(input) ? "pipe" : input;
+	const outputToStdioOption = (input) => isSink(input) ? "pipe" : input;
+	const resolveStdinOption = (options) => {
+		const defaultConfig = {
+			stream: "pipe",
+			encoding: "utf-8",
+			endOnDone: true
+		};
+		if (isUndefined(options.stdin)) return defaultConfig;
+		if (typeof options.stdin === "string") return {
+			...defaultConfig,
+			stream: options.stdin
+		};
+		if (isStream(options.stdin)) return {
+			...defaultConfig,
+			stream: options.stdin
+		};
+		return {
+			stream: options.stdin.stream,
+			encoding: options.stdin.encoding ?? defaultConfig.encoding,
+			endOnDone: options.stdin.endOnDone ?? defaultConfig.endOnDone
+		};
+	};
+	const resolveOutputOption = (options, streamName) => {
+		const option = options[streamName];
+		if (isUndefined(option)) return { stream: "pipe" };
+		if (typeof option === "string") return { stream: option };
+		if (isSink(option)) return { stream: option };
+		return { stream: option.stream };
+	};
+	const resolveAdditionalFds = (options) => {
+		if (isUndefined(options.additionalFds)) return [];
+		const result = [];
+		for (const [name, config] of Object.entries(options.additionalFds)) {
+			const fd = parseFdName(name);
+			if (isNotUndefined(fd)) result.push({
+				fd,
+				config
+			});
+		}
+		return result.sort((a, b) => a.fd - b.fd);
+	};
+	const buildStdioArray = (stdinConfig, stdoutConfig, stderrConfig, additionalFds) => {
+		const stdio = [
+			inputToStdioOption(stdinConfig.stream),
+			outputToStdioOption(stdoutConfig.stream),
+			outputToStdioOption(stderrConfig.stream)
+		];
+		if (additionalFds.length === 0) return stdio;
+		const maxFd = additionalFds.reduce((max, { fd }) => Math.max(max, fd), 2);
+		for (let i = 3; i <= maxFd; i++) stdio[i] = "ignore";
+		for (const { fd } of additionalFds) stdio[fd] = "pipe";
+		return stdio;
+	};
+	const runInputStream = (stream, sink, inputFailure) => forkScoped(run(tapError(stream, (error) => fail$2(inputFailure, error)), sink));
+	const setupAdditionalFds = fnUntraced(function* (command, childProcess, additionalFds, inputFailure) {
+		if (additionalFds.length === 0) return {
+			getInputFd: () => drain,
+			getOutputFd: () => empty
+		};
+		const inputSinks = /* @__PURE__ */ new Map();
+		const outputStreams = /* @__PURE__ */ new Map();
+		const setupInput = (fd, nodeStream, stream) => suspend(() => {
+			let sink = drain;
+			if (nodeStream && "write" in nodeStream) {
+				handleInputErrors(nodeStream);
+				sink = fromWritable({
+					evaluate: () => nodeStream,
+					onError: (error) => toPlatformError(`fromWritable(fd${fd})`, toError(error), command)
+				});
+			}
+			if (stream) return map(runInputStream(stream, sink, inputFailure), () => {
+				inputSinks.set(fd, sink);
+			});
+			inputSinks.set(fd, sink);
+			return void_$1;
+		});
+		const setupOutput = (fd, nodeStream, sink) => {
+			let stream = empty;
+			if (nodeStream && "read" in nodeStream) {
+				const passThrough = new PassThrough();
+				let error = void 0;
+				passThrough.on("error", (cause) => {
+					error ??= cause;
+				});
+				nodeStream.on("error", (cause) => passThrough.destroy(cause));
+				nodeStream.pipe(passThrough);
+				const onError = (cause) => toPlatformError(`fromReadable(fd${fd})`, toError(cause), command);
+				stream = suspend$1(() => error === void 0 ? fromReadable({
+					evaluate: () => passThrough,
+					onError
+				}) : fail$3(onError(error)));
+			}
+			if (sink) stream = transduce(stream, sink);
+			outputStreams.set(fd, stream);
+		};
+		for (const { config, fd } of additionalFds) {
+			const nodeStream = childProcess.stdio[fd];
+			switch (config.type) {
+				case "input":
+					yield* setupInput(fd, nodeStream, config.stream);
+					break;
+				case "output":
+					setupOutput(fd, nodeStream, config.sink);
+					break;
+				case "duplex":
+					if (nodeStream && "allowHalfOpen" in nodeStream) nodeStream.allowHalfOpen = true;
+					setupOutput(fd, nodeStream, config.sink);
+					yield* setupInput(fd, nodeStream, config.stream);
+			}
+		}
+		return {
+			getInputFd: (fd) => inputSinks.get(fd) ?? drain,
+			getOutputFd: (fd) => outputStreams.get(fd) ?? empty
+		};
+	});
+	const setupChildStdin = (command, childProcess, config, inputFailure) => suspend(() => {
+		let sink = drain;
+		if (isNotNull(childProcess.stdin)) {
+			handleInputErrors(childProcess.stdin);
+			sink = fromWritable({
+				evaluate: () => childProcess.stdin,
+				onError: (error) => toPlatformError("fromWritable(stdin)", toError(error), command),
+				endOnDone: config.endOnDone,
+				encoding: config.encoding
+			});
+		}
+		if (isStream(config.stream)) return as(runInputStream(config.stream, sink, inputFailure), sink);
+		return succeed(sink);
+	});
+	const setupChildOutputStreams = (command, childProcess, stdoutConfig, stderrConfig) => {
+		let stdout = childProcess.stdout ? (() => {
+			const passThrough = new PassThrough();
+			childProcess.stdout.on("error", (error) => passThrough.destroy(error));
+			childProcess.stdout.pipe(passThrough);
+			return fromReadable({
+				evaluate: () => passThrough,
+				onError: (error) => toPlatformError("fromReadable(stdout)", toError(error), command)
+			});
+		})() : empty;
+		let stderr = childProcess.stderr ? (() => {
+			const passThrough = new PassThrough();
+			childProcess.stderr.on("error", (error) => passThrough.destroy(error));
+			childProcess.stderr.pipe(passThrough);
+			return fromReadable({
+				evaluate: () => passThrough,
+				onError: (error) => toPlatformError("fromReadable(stderr)", toError(error), command)
+			});
+		})() : empty;
+		if (isSink(stdoutConfig.stream)) stdout = transduce(stdout, stdoutConfig.stream);
+		if (isSink(stderrConfig.stream)) stderr = transduce(stderr, stderrConfig.stream);
+		const all = merge(stdout, stderr);
+		return {
+			stdout,
+			stderr,
+			all
+		};
+	};
+	const spawn = (command, spawnOptions) => callback((resume) => {
+		const deferred = makeUnsafe$1();
+		const handle = NodeChildProcess.spawn(command.command, command.args.map(unwrap), spawnOptions);
+		handle.on("error", (error) => {
+			if (command.args.some(isRedacted)) Object.assign(error, { spawnargs: [command.command, ...command.args.map((arg) => isRedacted(arg) ? "<redacted>" : arg)] });
+			resume(fail$1(toPlatformError("spawn", error, command)));
+		});
+		handle.on("exit", (...args) => {
+			doneUnsafe(deferred, succeed$1(args));
+		});
+		handle.on("spawn", () => {
+			resume(succeed([handle, deferred]));
+		});
+		return sync(() => {
+			handle.kill("SIGTERM");
+		});
+	});
+	const killProcessGroup = (command, childProcess, signal) => {
+		if (globalThis.process.platform === "win32") return callback((resume) => {
+			taskkill(childProcess, (error) => {
+				if (error) resume(fail$1(toPlatformError("kill", toError(error), command)));
+				else resume(void_$1);
+			});
+		});
+		return try_({
+			try: () => {
+				globalThis.process.kill(-childProcess.pid, signal);
+			},
+			catch: (error) => toPlatformError("kill", toError(error), command)
+		});
+	};
+	const killProcessGroupOnExit = (childProcess, signal) => {
+		if (globalThis.process.platform === "win32") {
+			taskkill(childProcess);
+			return;
+		}
+		try {
+			globalThis.process.kill(-childProcess.pid, signal);
+		} catch {}
+	};
+	const killProcess = (command, childProcess, signal) => suspend(() => {
+		if (!childProcess.kill(signal)) {
+			const error = new globalThis.Error("Failed to kill child process");
+			return fail$1(toPlatformError("kill", error, command));
+		}
+		return void_$1;
+	});
+	/** Waits for the leader and its process group, bounded by native time. */
+	const awaitProcessExit = (command, childProcess, timeoutMillis) => callback((resume) => {
+		const deadline = Date.now() + timeoutMillis;
+		let timer;
+		const stop = () => {
+			clearTimeout(timer);
+			childProcess.removeListener("exit", poll);
+		};
+		const poll = () => {
+			clearTimeout(timer);
+			if (Date.now() >= deadline || !isProcessAlive(command, childProcess)) {
+				stop();
+				resume(void_$1);
+				return;
+			}
+			timer = setTimeout(poll, processGroupPollIntervalMillis);
+		};
+		childProcess.on("exit", poll);
+		poll();
+		return sync(stop);
+	});
+	const terminateProcessGroup = fnUntraced(function* (command, childProcess, exitSignal, options) {
+		const signalGroup = (signal) => ownsProcessGroup(command, childProcess) ? killProcessGroup(command, childProcess, signal).pipe(catch_((error) => hasExited(childProcess) && isUnsignallableProcessGroup(error.cause) ? void_$1 : killProcess(command, childProcess, signal))) : killProcess(command, childProcess, signal);
+		yield* signalGroup(options?.killSignal ?? "SIGTERM");
+		if (isUndefined(options?.forceKillAfter)) {
+			yield* _await(exitSignal);
+			yield* awaitProcessExit(command, childProcess, processGroupGraceMillis);
+		} else {
+			yield* awaitProcessExit(command, childProcess, toMillis(options.forceKillAfter));
+			if (isProcessAlive(command, childProcess)) {
+				yield* signalGroup("SIGKILL");
+				yield* awaitProcessExit(command, childProcess, processGroupGraceMillis);
+			}
+		}
+		yield* _await(exitSignal);
+	});
+	/**
+	* Get the appropriate source stream from a process handle based on the
+	* `from` pipe option.
+	*/
+	const getSourceStream = (handle, from) => {
+		const fromOption = from ?? "stdout";
+		switch (fromOption) {
+			case "stdout": return handle.stdout;
+			case "stderr": return handle.stderr;
+			case "all": return handle.all;
+			default: {
+				const fd = parseFdName(fromOption);
+				if (isNotUndefined(fd)) return handle.getOutputFd(fd);
+				return handle.stdout;
+			}
+		}
+	};
+	const spawnCommand = fnUntraced(function* (cmd) {
+		switch (cmd._tag) {
+			case "StandardCommand": {
+				if (cmd.options.shell !== void 0 && cmd.options.shell !== false && cmd.args.length > 0) return yield* fail$1(badArgument({
+					module: "ChildProcess",
+					method: "spawn",
+					description: "The shell option cannot be combined with arguments; pass the whole script as the command"
+				}));
+				const nulCharacter = findNulCharacter(cmd);
+				if (nulCharacter !== void 0) return yield* fail$1(badArgument({
+					module: "ChildProcess",
+					method: "spawn",
+					description: nulCharacter
+				}));
+				const stdinConfig = resolveStdinOption(cmd.options);
+				const stdoutConfig = resolveOutputOption(cmd.options, "stdout");
+				const stderrConfig = resolveOutputOption(cmd.options, "stderr");
+				const resolvedAdditionalFds = resolveAdditionalFds(cmd.options);
+				let isReferenced = true;
+				const cwd = yield* resolveWorkingDirectory(cmd.options);
+				const env = resolveEnvironment(cmd.options);
+				const stdio = buildStdioArray(stdinConfig, stdoutConfig, stderrConfig, resolvedAdditionalFds);
+				const [childProcess, exitSignal] = yield* acquireRelease(spawn(cmd, buildSpawnOptions(cmd.options, {
+					cwd,
+					env,
+					stdio
+				}, process.platform)), fnUntraced(function* ([childProcess, exitSignal]) {
+					if (yield* isDone(exitSignal)) {
+						const [code] = yield* _await(exitSignal);
+						if (code !== 0 && isNotNull(code)) yield* ignore(terminateProcessGroup(cmd, childProcess, exitSignal, cmd.options));
+						else if (isReferenced && process.platform !== "win32" && cmd.options.detached !== false) yield* ignore(terminateProcessGroup(cmd, childProcess, exitSignal, cmd.options));
+						return;
+					}
+					if (!isReferenced) return;
+					yield* ignore(terminateProcessGroup(cmd, childProcess, exitSignal, cmd.options));
+				}));
+				const pid = ProcessId(childProcess.pid);
+				if (cmd.options.detached !== false) childProcess.on("exit", (code) => {
+					if (code !== 0 && isNotNull(code)) killProcessGroupOnExit(childProcess, cmd.options.killSignal ?? "SIGTERM");
+				});
+				const reref = sync(() => {
+					if (!isReferenced) {
+						childProcess.ref();
+						isReferenced = true;
+					}
+				});
+				const unref = sync(() => {
+					if (isReferenced) {
+						childProcess.unref();
+						isReferenced = false;
+					}
+					return reref;
+				});
+				const inputFailure = makeUnsafe$1();
+				const stdin = yield* setupChildStdin(cmd, childProcess, stdinConfig, inputFailure);
+				const { all, stderr, stdout } = setupChildOutputStreams(cmd, childProcess, stdoutConfig, stderrConfig);
+				const { getInputFd, getOutputFd } = yield* setupAdditionalFds(cmd, childProcess, resolvedAdditionalFds, inputFailure);
+				const isRunning = map(isDone(exitSignal), (done) => !done);
+				const exitCode = flatMap(raceFirst(_await(exitSignal), _await(inputFailure)), ([code, signal]) => {
+					if (isDoneUnsafe(inputFailure)) return _await(inputFailure);
+					if (isNotNull(code)) return succeed(ExitCode(code));
+					const error = new globalThis.Error(`Process interrupted due to receipt of signal: '${signal}'`);
+					return fail$1(toPlatformError("exitCode", error, cmd));
+				});
+				const kill = (options) => terminateProcessGroup(cmd, childProcess, exitSignal, options);
+				return makeHandle({
+					pid,
+					exitCode,
+					isRunning,
+					kill,
+					stdin,
+					stdout,
+					stderr,
+					all,
+					getInputFd,
+					getOutputFd,
+					unref
+				});
+			}
+			case "PipedCommand": {
+				const { commands, pipeOptions } = flattenCommand(cmd);
+				const [root, ...pipeline] = commands;
+				const handles = [yield* spawnCommand(root)];
+				for (let i = 0; i < pipeline.length; i++) {
+					const command = pipeline[i];
+					const options = pipeOptions[i] ?? {};
+					const stdinConfig = resolveStdinOption(command.options);
+					const sourceStream = unwrap$1(succeed(getSourceStream(handles[handles.length - 1], options.from)));
+					const toOption = options.to ?? "stdin";
+					if (toOption === "stdin") handles.push(yield* spawnCommand(make$5(command.command, command.args, {
+						...command.options,
+						stdin: {
+							...stdinConfig,
+							stream: sourceStream
+						}
+					})));
+					else {
+						const fd = parseFdName(toOption);
+						if (isNotUndefined(fd)) {
+							const fdName$1 = fdName(fd);
+							const existingFds = command.options.additionalFds ?? {};
+							const existingFd = existingFds[fdName$1];
+							const fdConfig = existingFd?.type === "duplex" ? {
+								...existingFd,
+								stream: sourceStream
+							} : {
+								type: "input",
+								stream: sourceStream
+							};
+							handles.push(yield* spawnCommand(make$5(command.command, command.args, {
+								...command.options,
+								additionalFds: {
+									...existingFds,
+									[fdName$1]: fdConfig
+								}
+							})));
+						} else handles.push(yield* spawnCommand(make$5(command.command, command.args, {
+							...command.options,
+							stdin: {
+								...stdinConfig,
+								stream: sourceStream
+							}
+						})));
+					}
+				}
+				const handle = handles[handles.length - 1];
+				const kill = (options) => forEach([...handles].reverse(), (handle) => ignore(handle.kill(options)), { discard: true });
+				const unref = gen(function* () {
+					const rerefs = [];
+					for (const handle of handles) rerefs.push(yield* handle.unref);
+					return forEach([...rerefs].reverse(), (reref) => reref, { discard: true });
+				});
+				return makeHandle({
+					pid: handle.pid,
+					exitCode: handle.exitCode,
+					isRunning: handle.isRunning,
+					kill,
+					stdin: handles[0].stdin,
+					stdout: handle.stdout,
+					stderr: handle.stderr,
+					all: handle.all,
+					getInputFd: handle.getInputFd,
+					getOutputFd: handle.getOutputFd,
+					unref
+				});
+			}
+		}
+	});
+	return make$6(spawnCommand);
+}));
+/**
+* Flattens a `Command` into an array of `StandardCommand`s along with pipe
+* options for each connection.
+*
+* @stability unstable
+* @category transforming
+* @since 4.0.0
+*/
+const flattenCommand = (command) => {
+	const commands = [];
+	const pipeOptions = [];
+	const flatten = (cmd) => {
+		switch (cmd._tag) {
+			case "StandardCommand":
+				commands.push(cmd);
+				break;
+			case "PipedCommand":
+				flatten(cmd.left);
+				pipeOptions.push(cmd.options);
+				flatten(cmd.right);
+		}
+	};
+	flatten(command);
+	if (commands.length === 0) throw new Error("flattenCommand produced empty commands array");
+	const [first, ...rest] = commands;
+	return {
+		commands: [first, ...rest],
+		pipeOptions
+	};
+};
+// ../../node_modules/.pnpm/@effect+platform-node@4.1.2_effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d795198_40a01a95710c8b08d9f921ebf3a75b9f/node_modules/@effect/platform-node/dist/NodeStdio.js
+/**
+* Node.js `Stdio` layer for the current process.
+*
+* The exported layer reuses the shared Node stdio implementation. It satisfies
+* the platform-independent `Stdio` service by reading command-line arguments
+* from `process.argv`, consuming input from `process.stdin`, and writing output
+* streams to `process.stdout` and `process.stderr`.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
+* Provides the `Stdio` service backed by the current process arguments,
+* stdin, stdout, and stderr streams.
+*
+* @stability unstable
+* @category layers
+* @since 4.0.0
+*/
+const layer$3 = /* @__PURE__ */ succeed$2(Stdio, /*#__PURE__*/ make$8({
+	args: /*#__PURE__*/ sync(() => process.argv.slice(2)),
+	stdinIsTerminal: /*#__PURE__*/ sync(() => process.stdin.isTTY === true),
+	stdoutIsTerminal: /*#__PURE__*/ sync(() => process.stdout.isTTY === true),
+	stderrIsTerminal: /*#__PURE__*/ sync(() => process.stderr.isTTY === true),
+	stdout: (options) => fromWritable({
+		evaluate: () => process.stdout,
+		onError: (cause) => systemError({
+			module: "Stdio",
+			method: "stdout",
+			_tag: "Unknown",
+			cause
+		}),
+		endOnDone: options?.endOnDone ?? false
+	}),
+	stderr: (options) => fromWritable({
+		evaluate: () => process.stderr,
+		onError: (cause) => systemError({
+			module: "Stdio",
+			method: "stderr",
+			_tag: "Unknown",
+			cause
+		}),
+		endOnDone: options?.endOnDone ?? false
+	}),
+	stdin: /*#__PURE__*/ fromReadable({
+		evaluate: () => process.stdin,
+		onError: (cause) => systemError({
+			module: "Stdio",
+			method: "stdin",
+			_tag: "Unknown",
+			cause
+		}),
+		closeOnDone: false
+	})
+}));
+/**
+* Provides the default process-backed `Terminal` service, ending key input on
+* bare Esc, Ctrl+C, or Ctrl+D.
+*
+* @stability unstable
+* @category layers
+* @since 4.0.0
+*/
+const layer$2 = /*#__PURE__*/ effect(Terminal, /*#__PURE__*/ (/* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQuit) {
+	const stdin = process.stdin;
+	const stdout = process.stdout;
+	const lines = yield* make$4();
+	let inputEnded = stdin.readableEnded;
+	let readlineActive = false;
+	const onStdinEnd = () => {
+		inputEnded = true;
+		if (!readlineActive) endUnsafe(lines);
+	};
+	stdin.once("end", onStdinEnd);
+	yield* addFinalizer$1(() => sync(() => stdin.off("end", onStdinEnd)));
+	const rlRef = yield* make$2({
+		acquire: acquireRelease(sync(() => {
+			const rl = readline.createInterface({
+				input: stdin,
+				escapeCodeTimeout: 50
+			});
+			const onLine = (line) => offerUnsafe(lines, line);
+			const onClose = () => {
+				readlineActive = false;
+				endUnsafe(lines);
+			};
+			readlineActive = true;
+			readline.emitKeypressEvents(stdin, rl);
+			rl.on("line", onLine);
+			rl.once("close", onClose);
+			return {
+				rl,
+				onClose,
+				onLine
+			};
+		}), ({ rl, onClose, onLine }) => sync(() => {
+			readlineActive = false;
+			rl.off("line", onLine);
+			rl.off("close", onClose);
+			rl.close();
+			if (inputEnded) endUnsafe(lines);
+		})),
+		idleTimeToLive: "10 millis"
+	});
+	const setRawMode = (enabled) => sync(() => {
+		if (stdin.isTTY) stdin.setRawMode(enabled);
+	});
+	const rawModeRef = yield* make$2({
+		acquire: acquireRelease(setRawMode(true), () => setRawMode(false)),
+		idleTimeToLive: "10 millis"
+	});
+	const columns = sync(() => stdout.columns ?? 0);
+	const rows = sync(() => stdout.rows ?? 0);
+	const size = gen(function* () {
+		const queue = yield* sliding(1);
+		const onResize = () => offerUnsafe(queue, {
+			columns: stdout.columns ?? 0,
+			rows: stdout.rows ?? 0
+		});
+		yield* addFinalizer$1(() => sync(() => {
+			stdout.off("resize", onResize);
+			endUnsafe(queue);
+		}));
+		stdout.on("resize", onResize);
+		onResize();
+		return queue;
+	});
+	const readInput = gen(function* () {
+		const queue = yield* make$4();
+		const handleKeypress = (s, k) => {
+			const userInput = {
+				input: fromUndefinedOr(s),
+				key: {
+					name: k.name ?? "",
+					ctrl: !!k.ctrl,
+					meta: !!k.meta,
+					shift: !!k.shift
+				}
+			};
+			offerUnsafe(queue, userInput);
+			if (shouldQuit(userInput)) endUnsafe(queue);
+		};
+		const keepAlive = setInterval(() => {}, 2147483647);
+		const handleEnd = () => {
+			clearInterval(keepAlive);
+			endUnsafe(queue);
+		};
+		yield* addFinalizer$1(() => sync(() => {
+			clearInterval(keepAlive);
+			stdin.off("keypress", handleKeypress);
+			stdin.off("end", handleEnd);
+		}));
+		stdin.on("keypress", handleKeypress);
+		if (inputEnded) handleEnd();
+		else {
+			yield* get(rlRef);
+			yield* get(rawModeRef);
+			stdin.once("end", handleEnd);
+		}
+		return queue;
+	});
+	const readLine = suspend(() => poll(lines).pipe(flatMap(match({
+		onNone: () => scoped(andThen(get(rlRef), take(lines))),
+		onSome: succeed
+	})), mapError(() => new QuitError({}))));
+	const display = (prompt) => uninterruptible(callback((resume) => {
+		stdout.write(prompt, (err) => isNullish(err) ? resume(void_$1) : resume(fail$1(badArgument({
+			module: "Terminal",
+			method: "display",
+			description: "Failed to write prompt to stdout",
+			cause: err
+		}))));
+	}));
+	return make$9({
+		columns,
+		rows,
+		size,
+		readInput,
+		readLine,
+		display
+	});
+}))(defaultShouldQuit));
+function defaultShouldQuit(input) {
+	const key = input.key;
+	return key.name === "escape" || key.ctrl && (key.name === "c" || key.name === "d");
+}
+// ../../node_modules/.pnpm/@effect+platform-node@4.1.2_effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d795198_40a01a95710c8b08d9f921ebf3a75b9f/node_modules/@effect/platform-node/dist/NodeServices.js
+/**
+* Provides the default Node implementations for child process spawning,
+* filesystem, path, stdio, and terminal services.
+*
+* @stability unstable
+* @category layers
+* @since 4.0.0
+*/
+const layer = /*#__PURE__*/ provideMerge(layer$5, /*#__PURE__*/ mergeAll(layer$6, layer$7, layer$3, layer$2));
+// src/cli-runtime.layer.ts
+const cliRuntime = mergeAll(AkterArchive.layer, Bench.layer, Deployment.layer, ActorExport.layer, ActorCall.layer).pipe(provideMerge(OperationCall.layer), provideMerge(mergeAll(layer, layer$8, layerWebCrypto$1, layerWebCrypto)));
+export { cliRuntime as t };