@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/actor-client.adapter-Coem7gF1.mjs

@@ -0,0 +1,3691 @@
+import { F as PipeInspectableProto, On as pipeArguments, S as none$1, Sn as identity, _ as isSome, _n as constUndefined, b as map, bn as dual, bt as setStackTraceLimit, gn as constTrue, gt as assignProperty, h as isNone, hn as constFalse, qt as hasProperty, un as isTagged, vn as constVoid, w as some, x as match, yt as getStackTraceLimit } from "./Option-DkxSnBhp.mjs";
+import { $i as encode, $r as isInterruptReason, $t as suspend$1, An as spaced, At as provideContext, B as flatMap, C as catch_, Ct as onExitPrimitive, Dr as isFailure, E as contextWith, En as exponential, Et as orDie, Gr as hasDies, Gt as scoped, Hn as effectContext, Hr as filterInterruptors, Ir as StackTrace, J as forkChild, Jn as succeed$2, Jr as interruptors, Jt as serviceOption, K as forEach, Kr as hasInterrupts, Lt as retry, M as fail, Mr as void_$1, N as failCause, Nn as upTo, Nt as raceFirst, O as die$1, On as min, Or as isSuccess, Pn as while_, Q as fromOption, Qn as close, R as filterOrFail, Rr as combine, Rt as runFork, Sn as yieldNow, Sr as failCause$1, St as onExit, T as context, Tr as interrupt$1, Un as effectDiscard, Ut as sandbox, Vn as effect, W as fnUntraced, Wr as fromReasons, Wt as scope, X as forkScoped, Xn as addFinalizer$1, Xt as succeed, Y as forkIn, Yn as Scope, Yt as sleep, Zn as addFinalizerExit, _r as succeed$3, aa as Service$1, at as isEffect, bn as withParentSpan, br as die$2, bt as never, ca as get, ci as squash, cr as done, da as getOrUndefinedUnsafe, dr as into, dt as map$1, ea as compose, en as sync, et as gen, fa as getUnsafe, fn as uninterruptible, gn as void_, gr as makeUnsafe$1, h as catchCauseIf, ha as merge, hn as useSpan, ht as mapError, i as addFinalizer$2, ia as Reference, in as timeout, ir as provide, it as interruptible, jr as succeed$1, jt as provideService, ki as forkUnsafe, kn as setInputType, kt as provide$1, l as as, ln as try_, lr as doneUnsafe, m as catchCause, ma as makeUnsafe$2, mn as updateContext, mr as isDoneUnsafe, n as acquireRelease, na as has, o as andThen, oa as add, on as timeoutOrElse, p as callback, pa as make$7, pn as uninterruptibleMask, pt as mapBothEager, qr as hasInterruptsOnly, r as acquireUseRelease, ra as toPredicate, rr as makeUnsafe$3, rt as interrupt, s as annotateCurrentSpan, sa as empty, sr as _await, st as logError, ta as fromPredicate, tn as tap, tt as ignore, ua as getOrUndefined, ut as makeSpanScoped, va as Prototype, vn as whileLoop, vt as matchCauseEffect, wt as onInterrupt, xn as withSpan, xr as fail$1, xt as onError, y as catchIf, yn as withFiber, yt as matchEffect, zr as die, zt as runForkWith } from "./Effect-CKFpqbmw.mjs";
+import { I as partition, K as empty$1, j as map$2, r as contains, u as findFirst } from "./Array-B4kuTQeW.mjs";
+import { $ as declare, An as InvalidType, B as TaggedStruct, Dt as isGreaterThanOrEqualTo, F as String$1, I as Struct, K as Uint8Array$1, Kn as empty$2, Nn as makeCompositeAtKey, Q as brand, S as Literals, T as NonEmptyArray, Ut as isMinLength, V as TaggedUnion, X as Unknown, Y as Union, Yt as isSchema, Z as Void, Zn as merge$1, _n as defaultParseOptions, a as Boolean, an as optionalKey, at as decodeUnknownEffect, bn as isNever, c as Class, cn as toCodecJson, d as Defect, en as link, et as declareConstructor, fn as omit, fr as map$3, g as Finite, ht as isBetween, i as BigIntFromString, in as optional, j as OptionFromNullOr, m as Exit, mt as is, n as ArraySchema, nn as makeFilter, or as fromEntries, p as Error$1, pn as decodeEffect, q as Uint8ArrayFromBase64, qn as fromInput, qt as isPattern, rt as decodeSync, s as Cause, sn as tag, st as encodeEffect, tn as make$8, v as Int, w as Never, wn as transform, x as Literal, z as TaggedError } from "./Schema-MiKt5K1v.mjs";
+import { l as millis$1, p as seconds } from "./Duration-EH9Vy4U6.mjs";
+import { i as TaggedError$1, r as TaggedClass } from "./Data-CeCULr0-.mjs";
+import { M as uint8Array, P as currentTimeMillis, j as text } from "./HttpClientResponse-D5ZKICVV.mjs";
+import { a as remove$1, i as has$1, n as empty$3, o as set, r as get$1 } from "./MutableHashMap-f8nW8AJR.mjs";
+import { D as mapAccum, G as runForEachArray, I as provideContext$1, R as retry$1, _t as interruptAll, ft as makeUnsafe$4, gt as interrupt$2, ht as getCurrent, nt as unwrap, vt as interruptAs, w as isStream, x as fromQueue, yt as join } from "./Stream-bK9QIETN.mjs";
+import { m as shutdownUnsafe, o as failCause$2, r as end, t as bounded$1, u as offerAll } from "./Queue-CO5UQ6os.mjs";
+import { t as SecureRandom } from "./SecureRandom-B_U4ysO3.mjs";
+import { t as WebCrypto } from "./WebCrypto-ZI_GNVlw.mjs";
+import { n as makeUnsafe$5 } from "./Semaphore-DOVJ4ZGS.mjs";
+import { a as webCryptoDigest, i as sha256 } from "./Digest-CBd3uv5B.mjs";
+import { a as option, r as Redacted, s as ConfigProvider } from "./Config-B6OND9WR.mjs";
+import { a as HttpClientErrorSchema } from "./HttpClientError-BUeMWx70.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/FiberMap.js
+/**
+* Manages fibers by key inside a scope.
+*
+* A `FiberMap<K, A, E>` owns a map of running fibers, interrupts them when its
+* scope closes, and automatically removes each entry when the corresponding
+* fiber completes. Use it when a program needs to start, replace, join, or
+* interrupt background work by a stable key while keeping all fibers tied to
+* one scope.
+*
+* @stability stable
+* @since 2.0.0
+*/
+const TypeId$6 = "~effect/FiberMap";
+/**
+* Returns `true` if a value is a `FiberMap`.
+*
+* **Details**
+*
+* This is a type guard that checks for the `FiberMap` runtime marker.
+*
+* **Example** (Checking if a value is a FiberMap)
+*
+* ```ts import.meta.vitest
+* import { Effect, FiberMap } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const map = yield* FiberMap.make<string>()
+*
+*   return [FiberMap.isFiberMap(map), FiberMap.isFiberMap({}), FiberMap.isFiberMap(null)]
+* })
+*
+* const actual = await Effect.runPromise(Effect.scoped(program))
+* actual // => [true, false, false]
+* ```
+*
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+const isFiberMap = (u) => hasProperty(u, TypeId$6);
+const Proto$2 = {
+	[TypeId$6]: TypeId$6,
+	[Symbol.iterator]() {
+		if (this.state._tag === "Closed") return empty$1();
+		return this.state.backing[Symbol.iterator]();
+	},
+	...PipeInspectableProto,
+	toJSON() {
+		return {
+			_id: "FiberMap",
+			state: this.state
+		};
+	}
+};
+const makeUnsafe = (backing, deferred) => {
+	const self = Object.create(Proto$2);
+	self.state = {
+		_tag: "Open",
+		backing,
+		fibers: /* @__PURE__ */ new Set()
+	};
+	self.deferred = deferred;
+	return self;
+};
+/**
+* Creates a scoped `FiberMap` for storing fibers by key.
+*
+* **Details**
+*
+* When the associated Scope is closed, all fibers in the map will be
+* interrupted. You can add fibers to the map using `FiberMap.set` or
+* `FiberMap.run`, and the fibers will be automatically removed from the
+* `FiberMap` when they complete.
+*
+* **Example** (Creating a scoped FiberMap)
+*
+* ```ts import.meta.vitest
+* import { Effect, FiberMap } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const map = yield* FiberMap.make<string>()
+*
+*   // run some effects and add the fibers to the map
+*   yield* FiberMap.run(map, "fiber a", Effect.never)
+*   yield* FiberMap.run(map, "fiber b", Effect.never)
+*
+*   yield* Effect.yieldNow
+*   return yield* FiberMap.size(map)
+* }).pipe(
+*   Effect.scoped // The fibers will be interrupted when the scope is closed
+* )
+*
+* const actual = await Effect.runPromise(program)
+* actual // => 2
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const make$6 = () => acquireRelease(sync(() => makeUnsafe(empty$3(), makeUnsafe$1())), (map) => suspend$1(() => {
+	const state = map.state;
+	if (state._tag === "Closed") return void_;
+	map.state = { _tag: "Closed" };
+	return interruptAll(state.fibers).pipe(into(map.deferred));
+}));
+const internalFiberId = -1;
+const isInternalInterruption = /*#__PURE__*/ toPredicate(/*#__PURE__*/ compose(filterInterruptors, /*#__PURE__*/ has(internalFiberId)));
+/**
+* Adds a fiber to the `FiberMap` under a key using a synchronous, unsafe
+* mutation.
+*
+* **When to use**
+*
+* Use when an existing forked fiber must be installed under a key immediately
+* and synchronous interruption of the replaced fiber is acceptable.
+*
+* **Details**
+*
+* When the fiber completes, it is removed from the map. If the key already has
+* a fiber, that previous fiber is interrupted unless `onlyIfMissing` is set;
+* in that case a different new fiber is interrupted and the existing entry is
+* kept, while re-registering the existing fiber is a no-op.
+*
+* **Example** (Adding a fiber unsafely)
+*
+* ```ts import.meta.vitest
+* import { Deferred, Effect, Fiber, FiberMap } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const map = yield* FiberMap.make<string>()
+*   const deferred = yield* Deferred.make<string>()
+*
+*   // Create a fiber and add it to the map
+*   const fiber = yield* Effect.forkChild(Deferred.await(deferred))
+*   FiberMap.setUnsafe(map, "greeting", fiber)
+*
+*   yield* Deferred.succeed(deferred, "Hello")
+*
+*   // Join the fiber to get its successful value
+*   return yield* Fiber.join(fiber)
+* })
+*
+* const actual = await Effect.runPromise(Effect.scoped(program))
+* actual // => "Hello"
+* ```
+*
+* @stability stable
+* @category combinators
+* @since 4.0.0
+*/
+const setUnsafe = /*#__PURE__*/ dual((args) => isFiberMap(args[0]), (self, key, fiber, options) => {
+	if (self.state._tag === "Closed") {
+		fiber.interruptUnsafe(internalFiberId);
+		return;
+	}
+	const previous = get$1(self.state.backing, key);
+	if (previous._tag === "Some") {
+		if (previous.value === fiber) return;
+		else if (options?.onlyIfMissing === true) {
+			fiber.interruptUnsafe(internalFiberId);
+			return;
+		}
+	}
+	set(self.state.backing, key, fiber);
+	self.state.fibers.add(fiber);
+	if (previous._tag === "Some") previous.value.interruptUnsafe(internalFiberId);
+	fiber.addObserver((exit) => {
+		if (self.state._tag === "Closed") return;
+		self.state.fibers.delete(fiber);
+		const current = get$1(self.state.backing, key);
+		if (isSome(current) && fiber === current.value) remove$1(self.state.backing, key);
+		if (isFailure(exit) && (options?.propagateInterruption === true ? !isInternalInterruption(exit.cause) : !hasInterruptsOnly(exit.cause))) doneUnsafe(self.deferred, exit);
+	});
+});
+/**
+* Checks whether a key exists in the FiberMap.
+*
+* **Example** (Checking if a key exists unsafely)
+*
+* ```ts import.meta.vitest
+* import { Effect, FiberMap } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const map = yield* FiberMap.make<string>()
+*
+*   // Add a fiber to the map
+*   yield* FiberMap.run(map, "task1", Effect.never)
+*
+*   // Check if keys exist
+*   return [FiberMap.hasUnsafe(map, "task1"), FiberMap.hasUnsafe(map, "task2")]
+* })
+*
+* const actual = await Effect.runPromise(Effect.scoped(program))
+* actual // => [true, false]
+* ```
+*
+* @stability stable
+* @category combinators
+* @since 4.0.0
+*/
+const hasUnsafe = /*#__PURE__*/ dual(2, (self, key) => self.state._tag === "Closed" ? false : has$1(self.state.backing, key));
+/**
+* Removes a fiber from the FiberMap, interrupting it if it exists.
+*
+* **Example** (Removing a fiber)
+*
+* ```ts import.meta.vitest
+* import { Effect, FiberMap } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const map = yield* FiberMap.make<string>()
+*
+*   // Add some fibers to the map
+*   yield* FiberMap.run(map, "task1", Effect.never)
+*   yield* FiberMap.run(map, "task2", Effect.never)
+*
+*   const sizeBefore = yield* FiberMap.size(map)
+*
+*   // Remove a specific fiber (this will interrupt it)
+*   yield* FiberMap.remove(map, "task1")
+*
+*   return [sizeBefore, yield* FiberMap.size(map)]
+* })
+*
+* const actual = await Effect.runPromise(Effect.scoped(program))
+* actual // => [2, 1]
+* ```
+*
+* @stability stable
+* @category combinators
+* @since 2.0.0
+*/
+const remove = /*#__PURE__*/ dual(2, (self, key) => suspend$1(() => {
+	if (self.state._tag === "Closed") return void_;
+	const fiber = get$1(self.state.backing, key);
+	if (fiber._tag === "None") return void_;
+	return interruptAs(fiber.value, internalFiberId);
+}));
+const constInterruptedFiber = /*#__PURE__*/ function() {
+	let fiber = void 0;
+	return () => {
+		if (fiber === void 0) fiber = runFork(interrupt);
+		return fiber;
+	};
+}();
+/**
+* Forks an Effect and stores the resulting fiber in the `FiberMap` under a key.
+*
+* **Details**
+*
+* When the fiber completes, it is removed from the map. If the key already has
+* a fiber, the previous fiber is interrupted unless `onlyIfMissing` is set.
+* Set `startImmediately: false` to defer startup. By default, the effect starts
+* immediately.
+*
+* **Example** (Forking effects into a map)
+*
+* ```ts import.meta.vitest
+* import { Effect, Fiber, FiberMap } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const map = yield* FiberMap.make<string>()
+*
+*   // Run effects and add the fibers to the map
+*   const fiber1 = yield* FiberMap.run(map, "task1", Effect.succeed("Hello"))
+*   const fiber2 = yield* FiberMap.run(map, "task2", Effect.succeed("World"))
+*
+*   // Join the fibers to get their successful values
+*   const result1 = yield* Fiber.join(fiber1)
+*   const result2 = yield* Fiber.join(fiber2)
+*   return [result1, result2, yield* FiberMap.size(map)]
+* })
+*
+* const actual = await Effect.runPromise(Effect.scoped(program))
+* actual // => ["Hello", "World", 0]
+* ```
+*
+* @stability stable
+* @category combinators
+* @since 2.0.0
+*/
+const run = function() {
+	const self = arguments[0];
+	if (isEffect(arguments[2])) return runImpl(self, arguments[1], arguments[2], arguments[3]);
+	const key = arguments[1];
+	const options = arguments[2];
+	return (effect) => runImpl(self, key, effect, options);
+};
+const runImpl = (self, key, effect, options) => withFiber((parent) => {
+	if (self.state._tag === "Closed") return interrupt;
+	else if (options?.onlyIfMissing === true && hasUnsafe(self, key)) return sync(constInterruptedFiber);
+	const fiber = forkUnsafe(parent, effect, options?.startImmediately ?? true, true);
+	setUnsafe(self, key, fiber, options);
+	return succeed(fiber);
+});
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/PrimaryKey.js
+/**
+* Defines the unique identifier used to identify objects that implement the `PrimaryKey` interface.
+*
+* **When to use**
+*
+* Use to implement the `PrimaryKey` protocol as a computed property key on
+* classes or object literals that expose a stable string identifier.
+*
+* @see {@link PrimaryKey} for the protocol interface that declares the method keyed by this symbol
+* @see {@link value} for reading the string key from a `PrimaryKey` value
+* @see {@link isPrimaryKey} for checking whether an unknown value carries this method
+*
+* @stability stable
+* @category symbols
+* @since 2.0.0
+*/
+const symbol = "~effect/PrimaryKey";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/workflow/internal/crypto.js
+const encoder$2 = /*#__PURE__*/ new TextEncoder();
+/**
+* Execution ids and idempotency keys are persisted, so they keep the first 16
+* bytes of the SHA-256 digest as 32 hex characters.
+*
+* @internal
+*/
+const makeHashDigest = (original) => WebCrypto.use((crypto) => map$1(webCryptoDigest(crypto, sha256, encoder$2.encode(original)), (bytes) => encode(bytes).slice(0, 32)));
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/workflow/Workflow.js
+/**
+* Defines typed durable workflows.
+*
+* A `Workflow` has a stable tag, schemas for payload, success, and failure, and
+* an idempotency key used to derive execution ids. Workflow definitions can be
+* executed, discarded, polled, interrupted, resumed, and registered with a
+* handler layer. This module also includes workflow result types, compensation
+* and cleanup helpers, suspension support, and settings for defect capture or
+* failure suspension.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+const TypeId$5 = "~effect/workflow/Workflow";
+const EngineTag$1 = /*#__PURE__*/ Service$1("effect/workflow/WorkflowEngine");
+const InstanceTag$1 = /*#__PURE__*/ Service$1("effect/workflow/WorkflowEngine/WorkflowInstance");
+const makeExecutionIdFromPayload = (self, payload) => makeHashDigest(`${self._tag.length}:${self._tag}:${self.idempotencyKey(payload)}`);
+const Proto$1 = {
+	[TypeId$5]: TypeId$5,
+	annotate(tag, value) {
+		return makeProto$2({
+			_tag: this._tag,
+			payloadSchema: this.payloadSchema,
+			successSchema: this.successSchema,
+			errorSchema: this.errorSchema,
+			annotations: add(this.annotations, tag, value),
+			idempotencyKey: this.idempotencyKey,
+			suspendedRetrySchedule: this.suspendedRetrySchedule
+		});
+	},
+	annotateMerge(context) {
+		return makeProto$2({
+			_tag: this._tag,
+			payloadSchema: this.payloadSchema,
+			successSchema: this.successSchema,
+			errorSchema: this.errorSchema,
+			annotations: merge(this.annotations, context),
+			idempotencyKey: this.idempotencyKey,
+			suspendedRetrySchedule: this.suspendedRetrySchedule
+		});
+	},
+	execute(fields, opts) {
+		return suspend$1(() => {
+			const payload = this.payloadSchema.make(fields);
+			const run = flatMap(EngineTag$1, (engine) => flatMap(makeExecutionIdFromPayload(this, payload), (executionId) => andThen(annotateCurrentSpan({ executionId }), engine.execute(this, {
+				executionId,
+				payload,
+				discard: opts?.discard,
+				detached: opts?.detached,
+				suspendedRetrySchedule: this.suspendedRetrySchedule
+			}))));
+			return opts?.discard ? run : withPendingActivity(run);
+		}).pipe(withSpan(`${this._tag}.execute`, {}, { captureStackTrace: false }));
+	},
+	poll(executionId) {
+		return flatMap(EngineTag$1, (engine) => engine.poll(this, executionId)).pipe(withSpan(`${this._tag}.poll`, { attributes: { executionId } }, { captureStackTrace: false }));
+	},
+	interrupt(executionId) {
+		return flatMap(EngineTag$1, (engine) => engine.interrupt(this, executionId)).pipe(withSpan(`${this._tag}.interrupt`, { attributes: { executionId } }, { captureStackTrace: false }));
+	},
+	resume(executionId) {
+		return flatMap(EngineTag$1, (engine) => engine.resume(this, executionId)).pipe(withSpan(`${this._tag}.resume`, { attributes: { executionId } }, { captureStackTrace: false }));
+	},
+	toLayer(execute) {
+		return effectDiscard(flatMap(EngineTag$1, (engine) => engine.register(this, execute)));
+	},
+	executionId(payload) {
+		return flatMap(orDie(this.payloadSchema.makeEffect(payload)), (payload) => makeExecutionIdFromPayload(this, payload));
+	},
+	withCompensation: (...args) => withCompensation(...args)
+};
+const makeProto$2 = (options) => {
+	function Workflow() {}
+	Object.setPrototypeOf(Workflow, Proto$1);
+	Object.assign(Workflow, options);
+	return Workflow;
+};
+/**
+* Creates a durable workflow definition with schemas, annotations, and
+* deterministic execution IDs derived from the workflow tag and idempotency
+* key.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make$5 = (tag, options) => makeProto$2({
+	_tag: tag,
+	payloadSchema: isSchema(options.payload) ? options.payload : Struct(options.payload),
+	successSchema: options.success ?? Void,
+	errorSchema: options.error ?? Never,
+	annotations: options.annotations ?? empty(),
+	idempotencyKey: options.idempotencyKey,
+	suspendedRetrySchedule: options.suspendedRetrySchedule
+});
+const ResultTypeId = "~effect/workflow/Workflow/Result";
+/**
+* Returns `true` when a value is a workflow `Result`.
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+const isResult = (u) => hasProperty(u, ResultTypeId);
+/**
+* Represents a completed workflow execution with its success or failure `Exit`.
+*
+* @stability unstable
+* @category models
+* @since 4.0.0
+*/
+var Complete = class Complete extends (/*#__PURE__*/ TaggedClass("Complete")) {
+	/**
+	* Marks this value as a workflow result for runtime guards.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	[ResultTypeId] = ResultTypeId;
+	/**
+	* Builds the schema for completed workflow results from success and error schemas.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	static Schema(options) {
+		const schema = declareConstructor()([Exit(options.success, options.error, Defect())], ([exit]) => (input, ast, options) => {
+			if (!(isResult(input) && input._tag === "Complete")) return fail(new InvalidType(ast, input, options));
+			return mapBothEager(decodeEffect(exit)(input.exit, options), {
+				onSuccess: (exit) => new Complete({ exit }),
+				onFailure: (issue) => makeCompositeAtKey(ast, "exit", issue, input, options)
+			});
+		}, {
+			expected: "Workflow.Complete",
+			toCodecJson: ([exit]) => link()(Struct({
+				_tag: tag("Complete"),
+				exit
+			}), transform({
+				decode: (encoded) => new Complete({ exit: encoded.exit }),
+				encode: (result) => ({
+					_tag: "Complete",
+					exit: result.exit
+				})
+			}))
+		});
+		return make$8(schema.ast, {
+			success: options.success,
+			error: options.error
+		});
+	}
+};
+/**
+* Represents a suspended workflow execution, optionally carrying the cause that
+* triggered suspension.
+*
+* **Details**
+*
+* `failed` marks this execution's own `SuspendOnFailure` and requires explicit
+* `resume` or `interrupt`. Inherited child failures do not set it.
+*
+* @stability unstable
+* @category schemas
+* @since 4.0.0
+*/
+var Suspended = class extends (/*#__PURE__*/ Class("effect/workflow/Workflow/Suspended")({
+	_tag: /*#__PURE__*/ tag("Suspended"),
+	cause: /*#__PURE__*/ optional(/*#__PURE__*/ Cause(Never, /*#__PURE__*/ Defect())),
+	failed: /*#__PURE__*/ optional(Boolean)
+})) {
+	/**
+	* Marks this value as a workflow result for runtime guards.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	[ResultTypeId] = ResultTypeId;
+};
+/**
+* Runs an effect as a workflow execution and converts its outcome into a
+* `Result`, handling suspension, defect capture, interruption, and workflow
+* scope finalization.
+*
+* @stability unstable
+* @category converting
+* @since 4.0.0
+*/
+const intoResult = (effect) => contextWith((context) => {
+	const instance = get(context, InstanceTag$1);
+	const captureDefects = get(instance.workflow.annotations, CaptureDefects);
+	const suspendOnFailure = get(instance.workflow.annotations, SuspendOnFailure);
+	return uninterruptibleMask((restore) => effect.pipe(forkChild({ startImmediately: true }), flatMap((fiber) => onInterrupt(restore(join(fiber)), () => interrupt$2(fiber))))).pipe(interruptible, suspendOnFailure ? catchCause((cause) => {
+		if (instance.abandoned || instance.interrupted) return failCause(cause);
+		instance.suspended = true;
+		if (!hasInterruptsOnly(cause)) {
+			instance.failed = true;
+			instance.cause = die(squash(cause));
+		}
+		return interrupt;
+	}) : identity, scoped, matchCauseEffect({
+		onSuccess: (value) => succeed(new Complete({ exit: succeed$1(value) })),
+		onFailure: (cause) => {
+			const [interrupts, reasons] = partition(cause.reasons, fromPredicate(isInterruptReason));
+			const hasInterruptsOnly = interrupts.length === cause.reasons.length;
+			const filtered = reasons.length === 0 ? cause : fromReasons(reasons);
+			const abandoned = instance.abandoned && !instance.interrupted && hasInterruptsOnly;
+			instance.abandoned = abandoned;
+			if (instance.suspended && hasInterruptsOnly && !abandoned) return succeed(new Suspended(instance.failed ? {
+				cause: instance.cause,
+				failed: true
+			} : { cause: instance.cause }));
+			if (!instance.interrupted && hasInterruptsOnly) return failCause(filtered);
+			return !captureDefects && hasDies(cause) ? failCause(filtered) : succeed(new Complete({ exit: failCause$1(filtered) }));
+		}
+	}), (eff) => onExitPrimitive(eff, (exit) => {
+		if (isFailure(exit)) return close(instance.scope, exit);
+		else if (exit.value._tag === "Complete") return close(instance.scope, exit.value.exit);
+		return void_;
+	}, true), uninterruptible);
+});
+/**
+* Wraps an activity-like effect so workflow suspension waits for currently
+* running activities to finish or suspend.
+*
+* @stability unstable
+* @category resource management
+* @since 4.0.0
+*/
+const wrapActivityResult = (effect, isSuspend) => contextWith((context) => {
+	const instance = get(context, InstanceTag$1);
+	return acquireUseRelease(sync(() => adoptActivityUnsafe(context, instance) ?? registerActivityUnsafe(instance)), () => effect, (registration, exit) => {
+		releaseActivityUnsafe(registration);
+		const isSuspended = isSuccess(exit) && isSuspend(exit.value);
+		if (isSuccess(exit) && isResult(exit.value) && exit.value._tag === "Suspended" && exit.value.cause) instance.cause = instance.cause ? combine(instance.cause, exit.value.cause) : exit.value.cause;
+		return isSuspended && instance.activityState.count > 0 ? waitForZero(instance) : void_;
+	});
+});
+const PendingActivityRegistration = /*#__PURE__*/ Service$1("effect/workflow/Workflow/PendingActivityRegistration");
+const registerActivityUnsafe = (instance) => {
+	const state = instance.activityState;
+	if (state.count === 0) state.latch.closeUnsafe();
+	state.count++;
+	return {
+		instance,
+		state: "pending"
+	};
+};
+const adoptActivityUnsafe = (context, instance) => {
+	const pending = getOrUndefined(context, PendingActivityRegistration);
+	if (!pending || pending.instance !== instance) return;
+	if (pending.state !== "pending") throw new Error("Workflow.wrapActivityResult: pending child registration has already been consumed");
+	pending.state = "adopted";
+	return pending;
+};
+const releaseActivityUnsafe = (registration) => {
+	if (registration.state === "released") return;
+	registration.state = "released";
+	const state = registration.instance.activityState;
+	state.count--;
+	if (state.count === 0) state.latch.openUnsafe();
+};
+/**
+* Registers a pending child workflow execution with the current workflow
+* instance before any asynchronous work runs. `wrapActivityResult` adopts the
+* registration once the execution is dispatched.
+*/
+const withPendingActivity = (effect) => contextWith((context) => {
+	const instance = getOrUndefined(context, InstanceTag$1);
+	if (!instance) return effect;
+	return acquireUseRelease(sync(() => registerActivityUnsafe(instance)), (registration) => provideService(effect, PendingActivityRegistration, registration), (registration) => sync(() => releaseActivityUnsafe(registration)));
+});
+const waitForZero = /*#__PURE__*/ fnUntraced(function* (instance) {
+	const state = instance.activityState;
+	while (true) {
+		if (state.count > 0) {
+			yield* state.latch.await;
+			yield* yieldNow;
+			continue;
+		}
+		yield* yieldNow;
+		if (state.count === 0) return;
+	}
+});
+/**
+* Adds an exit finalizer to the current workflow scope, preserving the
+* services available when the finalizer is registered.
+*
+* **Details**
+*
+* Body-level `Effect.onExit` finalizers cannot observe a deposited workflow
+* interrupt. Use this function for terminal-state work that must observe it.
+* Finalizers are skipped when a cluster owner abandons a run attempt for
+* replay; owner-local scope finalizers registered with {@link provideScope}
+* still run.
+*
+* @stability unstable
+* @category resource management
+* @since 4.0.0
+*/
+const addFinalizer = /*#__PURE__*/ fnUntraced(function* (f) {
+	const instance = yield* InstanceTag$1;
+	const services = yield* context();
+	yield* addFinalizerExit(instance.scope, (exit) => instance.abandoned ? void_ : provideContext(f(exit), services));
+});
+/**
+* Adds compensation logic to an effect inside a Workflow.
+*
+* **When to use**
+*
+* Use when a top-level workflow step needs compensating cleanup if the overall
+* workflow later fails after the step succeeds.
+*
+* **Details**
+*
+* The compensation finalizer is called if the entire workflow fails, allowing you to perform cleanup or other actions based on the success value and the cause of the workflow failure.
+*
+* **Gotchas**
+*
+* Compensation finalizers are only registered for top-level effects in the workflow and do not work for nested activities.
+*
+* @stability unstable
+* @category compensation
+* @since 4.0.0
+*/
+const withCompensation = /*#__PURE__*/ dual(2, (effect, compensation) => uninterruptibleMask((restore) => tap(restore(effect), (value) => addFinalizer((exit) => isSuccess(exit) ? void_ : compensation(value, exit.cause)))));
+/**
+* Marks a workflow instance as suspended and interrupts the current fiber to
+* stop execution until it is resumed.
+*
+* @stability unstable
+* @category interruption
+* @since 4.0.0
+*/
+const suspend = (instance) => interruptible(callback(() => {
+	instance.suspended = true;
+	const fiber = getCurrent();
+	fiber.interruptUnsafe(fiber.id);
+}));
+/**
+* Captures defects for a workflow and includes them in the result of the workflow or its activities.
+*
+* **Details**
+*
+* By default, this annotation is set to `true`, meaning defects are captured.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const CaptureDefects = /*#__PURE__*/ Reference("effect/workflow/Workflow/CaptureDefects", { defaultValue: constTrue });
+/**
+* Marks a workflow to suspend when it encounters any error.
+*
+* **Details**
+*
+* The suspended execution can later be resumed with the workflow's `resume` method, for example `MyWorkflow.resume(executionId)`.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const SuspendOnFailure = /*#__PURE__*/ Reference("effect/workflow/Workflow/SuspendOnFailure", { defaultValue: constFalse });
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/workflow/Activity.js
+const TypeId$4 = "~effect/workflow/Activity";
+/**
+* Creates a workflow activity from an effect, using the provided schemas to
+* encode successes and failures for durable execution.
+*
+* **Gotchas**
+*
+* Only completed activity results are memoized. If the activity suspends while
+* awaiting child workflows or a durable clock, its body runs again when the
+* parent workflow replays. Side effects before the suspension can repeat;
+* make those side effects idempotent.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make$4 = (options) => {
+	const successSchema = options.success ?? Void;
+	const errorSchema = options.error ?? Never;
+	const successSchemaJson = toCodecJson(successSchema);
+	const errorSchemaJson = toCodecJson(errorSchema);
+	let execute;
+	const executeWithoutInterrupt = retryOnInterrupt(options.name, options.interruptRetryPolicy)(options.execute);
+	const self = {
+		...Prototype({
+			label: "Activity",
+			evaluate(_) {
+				return execute;
+			}
+		}),
+		[TypeId$4]: TypeId$4,
+		name: options.name,
+		successSchema,
+		errorSchema,
+		exitSchema: Exit(successSchemaJson, errorSchemaJson, Defect()),
+		exitSchemaPartial: Exit(successSchemaJson, errorSchemaJson, Unknown),
+		annotations: options.annotations ?? empty(),
+		annotate(tag, value) {
+			return make$4({
+				...options,
+				annotations: add(self.annotations, tag, value)
+			});
+		},
+		annotateMerge(context) {
+			return make$4({
+				...options,
+				annotations: merge(self.annotations, context)
+			});
+		},
+		execute: executeWithoutInterrupt,
+		executeEncoded: matchEffect(executeWithoutInterrupt, {
+			onFailure: (error) => flatMap(orDie(encodeEffect(errorSchemaJson)(error)), fail),
+			onSuccess: (value) => orDie(encodeEffect(successSchemaJson)(value))
+		})
+	};
+	execute = makeExecute(self);
+	return self;
+};
+const interruptRetryPolicy = /*#__PURE__*/ min([exponential(400, 1.5), spaced("10 seconds")]).pipe(/*#__PURE__*/ setInputType(), /*#__PURE__*/ while_((meta) => meta.attempt <= 10 && hasInterrupts(meta.input)));
+const retryOnInterrupt = (name, policy = interruptRetryPolicy) => (effect) => flatMap(InstanceTag, (instance) => effect.pipe(sandbox, retry({
+	schedule: policy,
+	while: () => !instance.suspended
+}), catch_((cause) => hasInterrupts(cause) && !instance.suspended ? die$1(`Activity "${name}" interrupted and retry attempts exhausted`) : failCause(cause))));
+/**
+* Context reference containing the current activity retry attempt, defaulting
+* to `1`.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const CurrentAttempt = /*#__PURE__*/ Reference("effect/workflow/Activity/CurrentAttempt", { defaultValue: () => 1 });
+/**
+* Computes a deterministic activity idempotency key from the current workflow
+* execution ID, the supplied name, and optionally the current attempt.
+*
+* @stability unstable
+* @category idempotency
+* @since 4.0.0
+*/
+const idempotencyKey = /*#__PURE__*/ fnUntraced(function* (name, options) {
+	let key = `${(yield* InstanceTag).executionId}`;
+	if (options?.includeAttempt) {
+		const attempt = yield* CurrentAttempt;
+		key += `-${attempt}`;
+	}
+	key += `-${name}`;
+	return yield* makeHashDigest(key);
+});
+const EngineTag = /*#__PURE__*/ Service$1("effect/workflow/WorkflowEngine");
+const InstanceTag = /*#__PURE__*/ Service$1("effect/workflow/WorkflowEngine/WorkflowInstance");
+const makeExecute = /*#__PURE__*/ fnUntraced(function* (activity) {
+	const engine = yield* EngineTag;
+	const instance = yield* InstanceTag;
+	const attempt = yield* CurrentAttempt;
+	yield* annotateCurrentSpan({ executionId: instance.executionId });
+	const result = yield* wrapActivityResult(engine.activityExecute(activity, attempt), (_) => _._tag === "Suspended");
+	if (result._tag === "Suspended") {
+		if (result.failed) instance.failed = true;
+		return yield* suspend(instance);
+	}
+	return yield* result.exit;
+}, (effect, activity) => withSpan(effect, activity.name, { captureStackTrace: false }));
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/socket/Socket.js
+/**
+* Runtime type identifier attached to `Socket` services.
+*
+* @stability unstable
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId$3 = "~effect/socket/Socket";
+/**
+* Service tag for bidirectional socket transports.
+*
+* **When to use**
+*
+* Use to access or provide the socket implementation used by programs that
+* read and write frames through the Effect environment.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const Socket = /*#__PURE__*/ Service$1("effect/socket/Socket");
+/**
+* Constructs a `Socket` from a reader acquisition and a scoped writer.
+*
+* **Details**
+*
+* The reader must fail a suspended pull when its acquisition scope closes; see
+* `Socket` for why. A reader that leaves a pull blocked forever will hang any
+* consumer that shuts the socket down by closing that scope.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make$3 = (options) => Socket.of({
+	[TypeId$3]: TypeId$3,
+	reader: options.reader,
+	writer: options.writer
+});
+const encoder$1 = /*#__PURE__*/ new TextEncoder();
+const CloseEventTypeId = "~effect/socket/Socket/CloseEvent";
+/**
+* Returns `true` when a value is a `CloseEvent`.
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+const isCloseEvent = (u) => hasProperty(u, CloseEventTypeId);
+/**
+* Runtime type identifier attached to `SocketError` values.
+*
+* @stability unstable
+* @category type IDs
+* @since 4.0.0
+*/
+const SocketErrorTypeId = "~effect/socket/Socket/SocketError";
+/**
+* Returns `true` when a value is a `SocketError`.
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+const isSocketError = (u) => hasProperty(u, SocketErrorTypeId);
+/**
+* Typed error for failures that occur while reading from a socket.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketReadError = class extends (/*#__PURE__*/ Error$1("effect/socket/Socket/SocketReadError")({
+	_tag: /*#__PURE__*/ tag("SocketReadError"),
+	cause: /*#__PURE__*/ Defect()
+})) {
+	/**
+	* Default message used for socket read failures.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	message = `An error occurred during Read`;
+};
+/**
+* Typed error for failures that occur while writing to a socket.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketWriteError = class extends (/*#__PURE__*/ Error$1("effect/socket/Socket/SocketWriteError")({
+	_tag: /*#__PURE__*/ tag("SocketWriteError"),
+	cause: /*#__PURE__*/ Defect()
+})) {
+	/**
+	* Default message used for socket write failures.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	message = `An error occurred during Write`;
+};
+/**
+* Typed error for failures that occur while opening a socket, including
+* unknown open failures and open timeouts.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketOpenError = class extends (/*#__PURE__*/ Error$1("effect/socket/Socket/SocketOpenError")({
+	_tag: /*#__PURE__*/ tag("SocketOpenError"),
+	kind: /*#__PURE__*/ Literals(["Unknown", "Timeout"]),
+	cause: /*#__PURE__*/ Defect()
+})) {
+	/**
+	* Formats timeout and unknown open failures for display.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	get message() {
+		return this.kind === "Timeout" ? `timeout waiting for "open"` : `An error occurred during Open`;
+	}
+};
+/**
+* Typed error for an unsupported or failed in-place TLS upgrade.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketUpgradeError = class SocketUpgradeError extends (/*#__PURE__*/ Error$1("effect/socket/Socket/SocketUpgradeError")({
+	_tag: /*#__PURE__*/ tag("SocketUpgradeError"),
+	cause: /*#__PURE__*/ optional(/*#__PURE__*/ Defect())
+})) {
+	/**
+	* An upgrade implementation for transports that cannot wrap the connection
+	* with TLS.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	static unsupported = () => fail(new SocketError({ reason: new SocketUpgradeError({}) }));
+	get message() {
+		return this.cause === void 0 ? `Socket does not support TLS upgrade` : `An error occurred during TLS upgrade`;
+	}
+};
+/**
+* Typed error for a socket close, carrying the close code and optional close
+* reason.
+*
+* **Details**
+*
+* Sockets never classify closes: any close, whatever the code, fails the
+* reader with a `SocketError` wrapping this reason. Consumers that treat a
+* close as normal catch it.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketCloseError = class extends (/*#__PURE__*/ Error$1("effect/socket/Socket/SocketCloseError")({
+	_tag: /*#__PURE__*/ tag("SocketCloseError"),
+	code: Int,
+	closeReason: /*#__PURE__*/ optional(String$1)
+})) {
+	get message() {
+		if (this.closeReason) return `${this.code}: ${this.closeReason}`;
+		return `${this.code}`;
+	}
+};
+/**
+* Schema for all socket-specific error reasons.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+const SocketErrorReason = /*#__PURE__*/ Union([
+	SocketReadError,
+	SocketWriteError,
+	SocketOpenError,
+	SocketUpgradeError,
+	SocketCloseError
+]);
+/**
+* Tagged error that wraps socket read, write, open, upgrade, and close failures
+* while preserving the underlying reason.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketError = class extends (/*#__PURE__*/ TaggedError(SocketErrorTypeId)("SocketError", {
+	_tag: /*#__PURE__*/ tag("SocketError"),
+	reason: SocketErrorReason
+})) {
+	constructor(props) {
+		if ("cause" in props.reason) super({
+			...props,
+			cause: props.reason.cause
+		});
+		else super(props);
+	}
+	/**
+	* Marks this value as a socket error wrapper for runtime guards.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	[SocketErrorTypeId] = SocketErrorTypeId;
+	/**
+	* Returns `true` when the value is a `SocketError`.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	static is(u) {
+		return isSocketError(u);
+	}
+	message = this.reason.message;
+};
+const closeError = (code, closeReason) => new SocketError({ reason: new SocketCloseError({
+	code,
+	closeReason
+}) });
+const isPausable = (ws) => "pause" in ws && typeof ws.pause === "function";
+/**
+* Builds a `Socket` from a scoped WebSocket acquisition effect.
+*
+* **Details**
+*
+* Reader acquisition runs `acquire`, attaches event listeners, then waits for
+* the socket to open. Implementations exposing `pause`/`resume` (the `ws`
+* package) remain flowing until buffered frames reach the configured
+* `highWaterMark` (64 KiB by default). Draining the buffer resumes the
+* transport. Incoming frames that arrive in the same tick are coalesced into
+* one batch. Implementations without pause (browsers) buffer incoming frames,
+* optionally failing the socket with a `SocketReadError` when `highWaterMark`
+* bytes are exceeded (default unbounded). Message boundaries survive: each
+* pulled batch contains one element per frame.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const fromWebSocket = (acquire, options) => withFiber((fiber) => {
+	let currentWS;
+	const latch = makeUnsafe$4(false);
+	const acquireContext = fiber.context;
+	const reader = gen(function* () {
+		const scope$2 = yield* scope;
+		const ws = yield* provide(acquire, scope$2);
+		if ("binaryType" in ws) ws.binaryType = "arraybuffer";
+		const pausable = isPausable(ws);
+		const highWaterMark = options?.highWaterMark ?? (pausable ? defaultHighWaterMark : void 0);
+		let open = ws.readyState === 1;
+		let paused = pausable && "isPaused" in ws && ws.isPaused === true;
+		let buffer = [];
+		let bufferSize = 0;
+		let error;
+		let waiter;
+		let openWaiter;
+		function pauseWebSocket() {
+			if (!pausable || paused) return;
+			ws.pause();
+			paused = true;
+		}
+		function resumeWebSocket() {
+			if (!pausable || !paused) return;
+			ws.resume();
+			paused = false;
+		}
+		function takeBuffer() {
+			const chunk = buffer;
+			buffer = [];
+			bufferSize = 0;
+			if (error === void 0) resumeWebSocket();
+			return chunk;
+		}
+		function deliver() {
+			if (waiter === void 0 || buffer.length === 0) return;
+			const resume = waiter;
+			waiter = void 0;
+			resume(succeed(takeBuffer()));
+		}
+		function push(data) {
+			buffer.push(data);
+			if (highWaterMark !== void 0) bufferSize += typeof data === "string" ? encoder$1.encode(data).byteLength : data.byteLength;
+			if (waiter !== void 0) deliver();
+			if (pausable && bufferSize >= highWaterMark) pauseWebSocket();
+			else if (!pausable && !waiter && highWaterMark !== void 0 && bufferSize > highWaterMark) fail$2(new SocketError({ reason: new SocketReadError({ cause: /* @__PURE__ */ new Error(`Socket highWaterMark of ${highWaterMark} bytes exceeded`) }) }));
+		}
+		function fail$2(err) {
+			if (error === void 0) error = err;
+			if (openWaiter !== void 0) {
+				const { cleanup, resume } = openWaiter;
+				openWaiter = void 0;
+				cleanup();
+				resume(fail(error));
+			}
+			if (waiter !== void 0) {
+				const resume = waiter;
+				waiter = void 0;
+				resume(buffer.length > 0 ? succeed(takeBuffer()) : fail(error));
+			}
+		}
+		function onMessage(event) {
+			const data = event.data;
+			if (typeof Blob !== "undefined" && data instanceof Blob) {
+				data.arrayBuffer().then((buf) => push(new Uint8Array(buf)), (cause) => {
+					fail$2(new SocketError({ reason: new SocketReadError({ cause }) }));
+				});
+				return;
+			}
+			push(data instanceof ArrayBuffer ? new Uint8Array(data) : data);
+		}
+		function onError(event) {
+			fail$2(new SocketError({ reason: open ? new SocketReadError({ cause: event }) : new SocketOpenError({
+				kind: "Unknown",
+				cause: event
+			}) }));
+		}
+		function onClose(event) {
+			fail$2(closeError(typeof event.code === "number" ? event.code : 1006, event.reason));
+		}
+		ws.addEventListener("message", onMessage);
+		ws.addEventListener("error", onError, { once: true });
+		ws.addEventListener("close", onClose, { once: true });
+		yield* addFinalizer$1(scope$2, sync(() => {
+			fail$2(closeError(1006));
+			ws.removeEventListener("message", onMessage);
+			ws.addEventListener("error", constVoid);
+			ws.removeEventListener("error", onError);
+			ws.removeEventListener("close", onClose);
+			if (pausable) try {
+				resumeWebSocket();
+			} catch {}
+			latch.closeUnsafe();
+			currentWS = void 0;
+		}));
+		if (ws.readyState >= 2) return yield* fail(error ?? closeError(1006));
+		if (!open) {
+			yield* callback((resume) => {
+				const onOpen = () => {
+					if (openWaiter?.resume !== resume) return;
+					openWaiter = void 0;
+					ws.removeEventListener("open", onOpen);
+					resume(void_);
+				};
+				const cleanup = () => ws.removeEventListener("open", onOpen);
+				openWaiter = {
+					resume,
+					cleanup
+				};
+				ws.addEventListener("open", onOpen, { once: true });
+				return sync(() => {
+					if (openWaiter?.resume === resume) openWaiter = void 0;
+					cleanup();
+				});
+			}).pipe(timeoutOrElse({
+				duration: options?.openTimeout ?? 1e4,
+				orElse: () => fail(new SocketError({ reason: new SocketOpenError({
+					kind: "Timeout",
+					cause: /* @__PURE__ */ new Error("timeout waiting for \"open\"")
+				}) }))
+			}));
+			open = true;
+		}
+		if (error === void 0 && bufferSize < highWaterMark) resumeWebSocket();
+		currentWS = ws;
+		latch.openUnsafe();
+		return {
+			pull: callback((resume) => {
+				if (buffer.length > 0) return resume(succeed(takeBuffer()));
+				if (error !== void 0) return resume(fail(error));
+				waiter = resume;
+				return sync(() => {
+					if (waiter === resume) waiter = void 0;
+				});
+			}),
+			upgrade: SocketUpgradeError.unsupported
+		};
+	}).pipe(updateContext((input) => merge(acquireContext, input)));
+	const write = (chunk) => suspend$1(() => {
+		const ws = currentWS;
+		if (ws === void 0) return latch.whenOpen(write(chunk));
+		try {
+			if (isCloseEvent(chunk)) ws.close(chunk.code, chunk.reason);
+			else ws.send(chunk);
+			return void_;
+		} catch (cause) {
+			return fail(new SocketError({ reason: new SocketWriteError({ cause }) }));
+		}
+	});
+	const writeAll = (chunks) => suspend$1(() => {
+		const ws = currentWS;
+		if (ws === void 0) return latch.whenOpen(writeAll(chunks));
+		try {
+			for (let i = 0; i < chunks.length; i++) ws.send(chunks[i]);
+			return void_;
+		} catch (cause) {
+			return fail(new SocketError({ reason: new SocketWriteError({ cause }) }));
+		}
+	});
+	const writer = succeed({
+		write,
+		writeAll
+	});
+	return succeed(make$3({
+		reader,
+		writer
+	}));
+});
+const defaultHighWaterMark = 65536;
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/rpc/RpcSchema.js
+/**
+* RPC schema markers and interruption annotations.
+*
+* This module contains the small pieces of schema metadata that the RPC
+* declaration, client, server, cluster, and reactivity layers share. It marks
+* streamed responses and annotates interruptions that came from a remote client
+* closing or cancelling a request.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+const StreamSchemaTypeId = "~effect/rpc/RpcSchema/StreamSchema";
+/**
+* Returns `true` when a schema is an RPC stream schema created by
+* `RpcSchema.Stream`.
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+function isStreamSchema(schema) {
+	return hasProperty(schema, StreamSchemaTypeId);
+}
+/**
+* @internal
+*/
+function getStreamSchemas(schema) {
+	return isStreamSchema(schema) ? some({
+		success: schema.success,
+		error: schema.error
+	}) : none$1();
+}
+const schema = /*#__PURE__*/ declare(isStream);
+/**
+* Creates an RPC stream schema from a stream element success schema and stream
+* error schema.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+function Stream(success, error) {
+	return make$8(schema.ast, {
+		[StreamSchemaTypeId]: StreamSchemaTypeId,
+		success,
+		error
+	});
+}
+/**
+* Annotation that marks interruptions that originate from an RPC client
+* abort.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+var ClientAbort = class extends (/*#__PURE__*/ Service$1()("effect/rpc/RpcSchema/ClientAbort")) {
+	static annotation = /*#__PURE__*/ this.context(true).pipe(/*#__PURE__*/ add(StackTrace, {
+		name: "ClientAbort",
+		stack: constUndefined,
+		parent: void 0
+	}));
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/rpc/Rpc.js
+const TypeId$2 = "~effect/rpc/Rpc";
+/**
+* Represents server-side metadata for the client associated with an RPC request.
+*
+* **When to use**
+*
+* Use to inspect or annotate the connected client while handling an RPC request
+* on the server.
+*
+* **Details**
+*
+* It stores the client id and request annotations that handlers can read or
+* extend.
+*
+* @stability unstable
+* @category models
+* @since 4.0.0
+*/
+var ServerClient = class {
+	id;
+	annotations;
+	constructor(id) {
+		this.id = id;
+		this.annotations = empty();
+	}
+	annotate(tag, value) {
+		this.annotations = add(this.annotations, tag, value);
+		return this;
+	}
+};
+const Proto = {
+	[TypeId$2]: TypeId$2,
+	pipe() {
+		return pipeArguments(this, arguments);
+	},
+	setSuccess(successSchema) {
+		return makeProto$1({
+			_tag: this._tag,
+			payloadSchema: this.payloadSchema,
+			successSchema,
+			errorSchema: this.errorSchema,
+			defectSchema: this.defectSchema,
+			annotations: this.annotations,
+			middlewares: this.middlewares
+		});
+	},
+	setError(errorSchema) {
+		return makeProto$1({
+			_tag: this._tag,
+			payloadSchema: this.payloadSchema,
+			successSchema: this.successSchema,
+			errorSchema,
+			defectSchema: this.defectSchema,
+			annotations: this.annotations,
+			middlewares: this.middlewares
+		});
+	},
+	setPayload(payloadSchema) {
+		return makeProto$1({
+			_tag: this._tag,
+			payloadSchema: isSchema(payloadSchema) ? payloadSchema : Struct(payloadSchema),
+			successSchema: this.successSchema,
+			errorSchema: this.errorSchema,
+			defectSchema: this.defectSchema,
+			annotations: this.annotations,
+			middlewares: this.middlewares
+		});
+	},
+	middleware(middleware) {
+		return makeProto$1({
+			_tag: this._tag,
+			payloadSchema: this.payloadSchema,
+			successSchema: this.successSchema,
+			errorSchema: this.errorSchema,
+			defectSchema: this.defectSchema,
+			annotations: this.annotations,
+			middlewares: /* @__PURE__ */ new Set([...this.middlewares, middleware])
+		});
+	},
+	prefix(prefix) {
+		return makeProto$1({
+			_tag: `${prefix}${this._tag}`,
+			payloadSchema: this.payloadSchema,
+			successSchema: this.successSchema,
+			errorSchema: this.errorSchema,
+			defectSchema: this.defectSchema,
+			annotations: this.annotations,
+			middlewares: this.middlewares
+		});
+	},
+	annotate(tag, value) {
+		return makeProto$1({
+			_tag: this._tag,
+			payloadSchema: this.payloadSchema,
+			successSchema: this.successSchema,
+			errorSchema: this.errorSchema,
+			defectSchema: this.defectSchema,
+			middlewares: this.middlewares,
+			annotations: add(this.annotations, tag, value)
+		});
+	},
+	annotateMerge(context) {
+		return makeProto$1({
+			_tag: this._tag,
+			payloadSchema: this.payloadSchema,
+			successSchema: this.successSchema,
+			errorSchema: this.errorSchema,
+			defectSchema: this.defectSchema,
+			middlewares: this.middlewares,
+			annotations: merge(this.annotations, context)
+		});
+	}
+};
+const makeProto$1 = (options) => {
+	function Rpc() {}
+	Object.setPrototypeOf(Rpc, Proto);
+	Object.assign(Rpc, options);
+	Rpc.key = `effect/rpc/Rpc/${options._tag}`;
+	return Rpc;
+};
+/**
+* Creates an RPC definition with the supplied tag and optional schemas.
+*
+* **Details**
+*
+* Payload options can be either a schema or struct fields. `stream: true` wraps
+* the success and error schemas in a stream schema and sets the normal error
+* schema to `Schema.Never`. `primaryKey` creates a payload class with a
+* primary key derived from the payload value.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make$2 = (tag, options) => {
+	const successSchema = options?.success ?? Void;
+	const errorSchema = options?.error ?? Never;
+	const defectSchema = options?.defect ?? Defect();
+	let payloadSchema;
+	if (options?.primaryKey) payloadSchema = class Payload extends Class(`effect/rpc/Rpc/${tag}`)(options.payload) {
+		[symbol]() {
+			return options.primaryKey(this);
+		}
+	};
+	else payloadSchema = isSchema(options?.payload) ? options?.payload : options?.payload ? Struct(options?.payload) : Void;
+	return makeProto$1({
+		_tag: tag,
+		payloadSchema,
+		successSchema: options?.stream ? Stream(successSchema, errorSchema) : successSchema,
+		errorSchema: options?.stream ? Never : errorSchema,
+		defectSchema,
+		annotations: empty(),
+		middlewares: /* @__PURE__ */ new Set()
+	});
+};
+const exitSchemaCache = /*#__PURE__*/ new WeakMap();
+/**
+* Builds the `Schema.Exit` used to encode and decode RPC results.
+*
+* **Details**
+*
+* The failure side includes the RPC error schema, middleware error schemas, and
+* stream error schema for streaming RPCs. Streaming RPCs use `Schema.Void` for
+* the exit success value. The schema is cached per RPC definition.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const exitSchema = (self) => {
+	if (exitSchemaCache.has(self)) return exitSchemaCache.get(self);
+	const rpc = self;
+	const failures = /* @__PURE__ */ new Set([rpc.errorSchema]);
+	const streamSchemas = getStreamSchemas(rpc.successSchema);
+	if (isSome(streamSchemas)) failures.add(streamSchemas.value.error);
+	for (const middleware of rpc.middlewares) failures.add(middleware.error);
+	const schema = Exit(isSome(streamSchemas) ? Void : rpc.successSchema, Union([...failures]), rpc.defectSchema);
+	exitSchemaCache.set(self, schema);
+	return schema;
+};
+/**
+* Annotation that sets the schema parse options used by `RpcClient` and
+* `RpcServer` when encoding and decoding an RPC's payload, success values,
+* stream chunks, and exits.
+*
+* **Details**
+*
+* The default value is `SchemaAST.defaultParseOptions`. Set `concurrency` to
+* parse product elements concurrently, which lets decoding transformations that
+* call `Effect.request` share `RequestResolver` batches. Annotate a single RPC
+* with `annotate`, or every RPC in a group with `RpcGroup.annotateRpcs`.
+*
+* @stability unstable
+* @category annotations
+* @since 4.0.0
+*/
+const ParseOptions = /*#__PURE__*/ Reference("effect/rpc/Rpc/ParseOptions", { defaultValue: () => defaultParseOptions });
+const WrapperTypeId = "~effect/rpc/Rpc/Wrapper";
+/**
+* Returns `true` when the value is an RPC `Wrapper`.
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+const isWrapper = (u) => WrapperTypeId in u;
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/rpc/RpcGroup.js
+const RpcGroupProto = {
+	add(...rpcs) {
+		const requests = new Map(this.requests);
+		for (const rpc of rpcs) requests.set(rpc._tag, rpc);
+		return makeProto({
+			requests,
+			annotations: this.annotations
+		});
+	},
+	merge(...groups) {
+		const requests = new Map(this.requests);
+		const annotations = new Map(this.annotations.mapUnsafe);
+		for (const group of groups) {
+			for (const [tag, rpc] of group.requests) requests.set(tag, rpc);
+			for (const [key, value] of group.annotations.mapUnsafe) annotations.set(key, value);
+		}
+		return makeProto({
+			requests,
+			annotations: makeUnsafe$2(annotations)
+		});
+	},
+	omit(...tags) {
+		const requests = new Map(this.requests);
+		for (const tag of tags) requests.delete(tag);
+		return makeProto({
+			requests,
+			annotations: this.annotations
+		});
+	},
+	middleware(middleware) {
+		const requests = /* @__PURE__ */ new Map();
+		for (const [tag, rpc] of this.requests) requests.set(tag, rpc.middleware(middleware));
+		return makeProto({
+			requests,
+			annotations: this.annotations
+		});
+	},
+	toHandlers(build) {
+		const self = this;
+		return gen(function* () {
+			const services = yield* context();
+			const handlers = isEffect(build) ? yield* build : build;
+			const contextMap = /* @__PURE__ */ new Map();
+			self.requests.forEach((rpc, tag) => {
+				contextMap.set(rpc.key, {
+					tag: rpc._tag,
+					handler: handlers[tag],
+					context: services
+				});
+			});
+			return makeUnsafe$2(contextMap);
+		});
+	},
+	prefix(prefix) {
+		const requests = /* @__PURE__ */ new Map();
+		for (const rpc of this.requests.values()) {
+			const newRpc = rpc.prefix(prefix);
+			requests.set(newRpc._tag, newRpc);
+		}
+		return makeProto({
+			requests,
+			annotations: this.annotations
+		});
+	},
+	toLayer(build) {
+		return effectContext(this.toHandlers(build));
+	},
+	of: identity,
+	toLayerHandler(service, build) {
+		const self = this;
+		return effectContext(gen(function* () {
+			const services = yield* context();
+			const handler = isEffect(build) ? yield* build : build;
+			const contextMap = /* @__PURE__ */ new Map();
+			const rpc = self.requests.get(service);
+			contextMap.set(rpc.key, {
+				handler,
+				context: services
+			});
+			return makeUnsafe$2(contextMap);
+		}));
+	},
+	accessHandler(service) {
+		return contextWith((parentContext) => {
+			const rpc = this.requests.get(service);
+			const { handler, context } = getOrUndefinedUnsafe(parentContext, rpc.key);
+			return succeed((payload, options) => {
+				options.rpc = rpc;
+				const result = handler(payload, options);
+				const effectOrStream = isWrapper(result) ? result.value : result;
+				return isEffect(effectOrStream) ? provide$1(effectOrStream, context) : provideContext$1(effectOrStream, context);
+			});
+		});
+	},
+	annotate(service, value) {
+		return makeProto({
+			requests: this.requests,
+			annotations: add(this.annotations, service, value)
+		});
+	},
+	annotateRpcs(service, value) {
+		return this.annotateRpcsMerge(make$7(service, value));
+	},
+	annotateMerge(context) {
+		return makeProto({
+			requests: this.requests,
+			annotations: merge(this.annotations, context)
+		});
+	},
+	annotateRpcsMerge(context) {
+		const requests = /* @__PURE__ */ new Map();
+		for (const [tag, rpc] of this.requests) requests.set(tag, rpc.annotateMerge(merge(context, rpc.annotations)));
+		return makeProto({
+			requests,
+			annotations: this.annotations
+		});
+	}
+};
+const makeProto = (options) => Object.assign(function() {}, RpcGroupProto, {
+	requests: options.requests,
+	annotations: options.annotations
+});
+/**
+* Creates an `RpcGroup` from one or more RPC definitions.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = (...rpcs) => makeProto({
+	requests: new Map(rpcs.map((rpc) => [rpc._tag, rpc])),
+	annotations: empty()
+});
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/workers/Transferable.js
+/**
+* Marks encoded worker message fields that should move through `postMessage` as
+* transfer-list entries.
+*
+* Worker messages still pass through schema encoding and structured clone, but
+* schemas wrapped with `schema` can also report backing resources such as
+* `ArrayBuffer`, `ImageData.data.buffer`, or `MessagePort` to a `Collector`.
+* Worker platforms then pass the collected values as the transfer list for the
+* same `postMessage` call, avoiding copies for large payloads and ports.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
+* Service for collecting `Transferable` objects while encoding worker messages
+* so they can be passed to `postMessage` transfer lists.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+var Collector = class extends (/*#__PURE__*/ Service$1()("effect/workers/Transferable/Collector")) {};
+/**
+* Creates a mutable `Collector` service directly, exposing unsafe synchronous
+* methods for reading, adding, and clearing collected transferables.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const makeCollectorUnsafe = () => {
+	let tranferables = [];
+	const unsafeAddAll = (transfers) => {
+		tranferables.push(...transfers);
+	};
+	const unsafeRead = () => tranferables;
+	const unsafeClear = () => {
+		const prev = tranferables;
+		tranferables = [];
+		return prev;
+	};
+	return Collector.of({
+		addAllUnsafe: unsafeAddAll,
+		addAll: (transferables) => sync(() => unsafeAddAll(transferables)),
+		readUnsafe: unsafeRead,
+		read: sync(unsafeRead),
+		clearUnsafe: unsafeClear,
+		clear: sync(unsafeClear)
+	});
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/workers/WorkerError.js
+/**
+* Worker error reason for failures while spawning or setting up a worker.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var WorkerSpawnError = class extends (/*#__PURE__*/ Error$1("effect/workers/WorkerError/WorkerSpawnError")({
+	_tag: /*#__PURE__*/ tag("WorkerSpawnError"),
+	message: String$1,
+	cause: /*#__PURE__*/ optional(/*#__PURE__*/ Defect())
+})) {};
+/**
+* Worker error reason for failures while sending a message to a worker.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var WorkerSendError = class extends (/*#__PURE__*/ Error$1("effect/workers/WorkerError/WorkerSendError")({
+	_tag: /*#__PURE__*/ tag("WorkerSendError"),
+	message: String$1,
+	cause: /*#__PURE__*/ optional(/*#__PURE__*/ Defect())
+})) {};
+/**
+* Worker error reason for failures while receiving or handling a message from a
+* worker.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var WorkerReceiveError = class extends (/*#__PURE__*/ Error$1("effect/workers/WorkerError/WorkerReceiveError")({
+	_tag: /*#__PURE__*/ tag("WorkerReceiveError"),
+	message: String$1,
+	cause: /*#__PURE__*/ optional(/*#__PURE__*/ Defect())
+})) {};
+/**
+* Worker error reason for an unclassified worker failure.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var WorkerUnknownError = class extends (/*#__PURE__*/ Error$1("effect/workers/WorkerError/WorkerUnknownError")({
+	_tag: /*#__PURE__*/ tag("WorkerUnknownError"),
+	message: String$1,
+	cause: /*#__PURE__*/ optional(/*#__PURE__*/ Defect())
+})) {};
+/**
+* Schema for decoding and encoding all supported worker error reason variants.
+*
+* @stability unstable
+* @category schemas
+* @since 4.0.0
+*/
+const WorkerErrorReason = /*#__PURE__*/ Union([
+	WorkerSpawnError,
+	WorkerSendError,
+	WorkerReceiveError,
+	WorkerUnknownError
+]);
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/rpc/internal/tracing.js
+/**
+* Names the span after the RPC method, or `${spanPrefix}.${tag}` when a prefix
+* is configured.
+*
+* @internal
+*/
+const spanName = (spanPrefix, tag) => spanPrefix === void 0 ? tag : `${spanPrefix}.${tag}`;
+/**
+* Default RPC span attributes, overridden by user `spanAttributes`.
+*
+* @internal
+*/
+const spanAttributes = (tag, attributes) => ({
+	"rpc.system.name": "effect_rpc",
+	"rpc.method": tag,
+	...attributes
+});
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/rpc/RpcClientError.js
+/**
+* Client-side protocol failures reported by unstable RPC transports.
+*
+* `RpcClientError` is the error type generated clients use when a call fails
+* before a remote handler can return its declared typed error. Its `reason`
+* covers built-in transport failures from HTTP, sockets, and workers, plus
+* `RpcClientDefect` values for malformed or incompatible protocol data.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+const TypeId$1 = "~effect/rpc/RpcClientError";
+/**
+* Represents a client-side RPC defect, such as a protocol violation or
+* decoding failure, with a message and original cause.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var RpcClientDefect = class extends (/*#__PURE__*/ Error$1("effect/rpc/RpcClientError/RpcClientDefect")({
+	_tag: /*#__PURE__*/ tag("RpcClientDefect"),
+	message: String$1,
+	cause: /*#__PURE__*/ Defect()
+})) {};
+/**
+* Error wrapper for RPC client failures, including worker, socket, HTTP client,
+* and client protocol defect failures.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var RpcClientError = class extends (/*#__PURE__*/ Error$1(TypeId$1)({
+	_tag: /*#__PURE__*/ tag("RpcClientError"),
+	reason: /*#__PURE__*/ Union([
+		WorkerErrorReason,
+		SocketErrorReason,
+		HttpClientErrorSchema,
+		RpcClientDefect
+	])
+})) {
+	/**
+	* Marks this value as an RPC client error for runtime guards.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	[TypeId$1] = TypeId$1;
+	get message() {
+		return `${this.reason._tag}: ${this.reason.message}`;
+	}
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/rpc/RpcMessage.js
+/**
+* Converts a bigint or string request id into the branded `RequestId` type.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const RequestId = (id) => id;
+/**
+* Represents the reusable `Eof` message value.
+*
+* @stability unstable
+* @category constants
+* @since 4.0.0
+*/
+const constEof = { _tag: "Eof" };
+/**
+* Represents the reusable `Ping` message value.
+*
+* @stability unstable
+* @category constants
+* @since 4.0.0
+*/
+const constPing = { _tag: "Ping" };
+/**
+* Creates a transport-encoded defect response around an already-encoded defect.
+*
+* **Details**
+*
+* Encode the defect with `protocol.codecFor(Schema.Defect())` before wrapping
+* it, because the codec that fills the defect hole belongs to the protocol.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const ResponseDefectEncoded = (encodedDefect) => ({
+	_tag: "Defect",
+	defect: encodedDefect
+});
+/**
+* Represents the reusable `Pong` message value.
+*
+* @stability unstable
+* @category constants
+* @since 4.0.0
+*/
+const constPong = { _tag: "Pong" };
+/**
+* Checks if the response type is terminal.
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+const isTerminalResponse = (response) => {
+	switch (response._tag) {
+		case "Exit":
+		case "Defect":
+		case "ClientProtocolError": return true;
+		default: return false;
+	}
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/rpc/RpcSerialization.js
+/**
+* Serializes RPC protocol messages for transports.
+*
+* `RpcSerialization` is the boundary between `RpcMessage` envelopes and the
+* bytes or strings carried by a transport. This module provides built-in
+* serializers for JSON, newline-delimited JSON, JSON-RPC 2.0, and SchemaBinary,
+* including framed formats that can decode multiple messages
+* from streaming chunks.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+const codecForJson = toCodecJson;
+let sharedTextDecoder;
+const decodeText = (bytes) => (sharedTextDecoder ??= new TextDecoder()).decode(bytes);
+/**
+* Service that describes how RPC protocol messages are encoded and decoded,
+* including the content type and whether the serialization format provides
+* message framing.
+*
+* **When to use**
+*
+* Use to provide the serialization boundary shared by RPC clients and servers
+* for a chosen wire format.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+var RpcSerialization = class extends (/*#__PURE__*/ Service$1()("effect/rpc/RpcSerialization")) {};
+/**
+* Error raised when a streaming parser retains more data than its configured
+* buffer limit.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var MaxBufferSizeExceeded = class extends (/*#__PURE__*/ TaggedError$1("MaxBufferSizeExceeded")) {
+	get message() {
+		return `RPC serialization buffer exceeded the maximum size of ${this.maxBufferSize}`;
+	}
+};
+/**
+* Error raised when a non-empty NDJSON frame is not valid JSON.
+* The `cause` field preserves the original JSON parsing error.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var NdjsonDecodeError = class extends (/*#__PURE__*/ TaggedError$1("NdjsonDecodeError")) {};
+const defaultMaxBufferSize = 16777216;
+const isBufferSizeExceeded = (bufferSize, maxBufferSize) => maxBufferSize !== "unbounded" && bufferSize > maxBufferSize;
+/**
+* JSON RPC serialization for whole message payloads. It does not include
+* message framing, so it is intended for transports that frame responses
+* themselves.
+*
+* @stability unstable
+* @category serialization
+* @since 4.0.0
+*/
+const json = /*#__PURE__*/ RpcSerialization.of({
+	contentType: "application/json",
+	includesFraming: false,
+	codecFor: codecForJson,
+	makeUnsafe: () => ({
+		decode: (bytes) => {
+			const decoded = JSON.parse(typeof bytes === "string" ? bytes : decodeText(bytes));
+			return Array.isArray(decoded) ? decoded : [decoded];
+		},
+		encode: (response) => JSON.stringify(response)
+	})
+});
+/**
+* Serializes RPC protocol messages as newline-delimited JSON, framing each message
+* with a trailing newline.
+*
+* @stability unstable
+* @category serialization
+* @since 4.0.0
+*/
+const makeNdjson = (options) => {
+	const maxBufferSize = options?.maxBufferSize ?? defaultMaxBufferSize;
+	return RpcSerialization.of({
+		contentType: "application/x-ndjson",
+		includesFraming: true,
+		codecFor: codecForJson,
+		makeUnsafe: () => {
+			let decoder;
+			let buffer = "";
+			const failMaxBufferSize = (maxBufferSize) => {
+				buffer = "";
+				throw new MaxBufferSizeExceeded({ maxBufferSize });
+			};
+			return {
+				decode: (bytes) => {
+					buffer += typeof bytes === "string" ? bytes : (decoder ??= new TextDecoder()).decode(bytes, { stream: true });
+					let position = 0;
+					let nlIndex = buffer.indexOf("\n", position);
+					const items = [];
+					while (nlIndex !== -1) {
+						if (isBufferSizeExceeded(nlIndex - position, maxBufferSize)) failMaxBufferSize(maxBufferSize);
+						const line = buffer.slice(position, buffer[nlIndex - 1] === "\r" ? nlIndex - 1 : nlIndex);
+						position = nlIndex + 1;
+						if (line.length > 0) try {
+							items.push(JSON.parse(line));
+						} catch (cause) {
+							buffer = "";
+							throw new NdjsonDecodeError({ cause });
+						}
+						nlIndex = buffer.indexOf("\n", position);
+					}
+					buffer = buffer.slice(position);
+					if (isBufferSizeExceeded(buffer.length, maxBufferSize)) failMaxBufferSize(maxBufferSize);
+					return items;
+				},
+				encode: (response) => {
+					if (Array.isArray(response)) {
+						if (response.length === 0) return void 0;
+						let data = "";
+						for (let i = 0; i < response.length; i++) data += JSON.stringify(response[i]) + "\n";
+						return data;
+					}
+					return JSON.stringify(response) + "\n";
+				}
+			};
+		}
+	});
+};
+/**
+* Default newline-delimited JSON RPC serialization.
+*
+* @stability unstable
+* @category serialization
+* @since 4.0.0
+*/
+const ndjson = /*#__PURE__*/ makeNdjson();
+/**
+* RPC serialization layer that uses NDJSON for serialization.
+*
+* **When to use**
+*
+* Use when you have a transport protocol that does not provide message framing.
+*
+* @see {@link layerJson} for transports that already provide message framing
+*
+* @stability unstable
+* @category layers
+* @since 4.0.0
+*/
+const layerNdjson = /*#__PURE__*/ succeed$2(RpcSerialization)(ndjson);
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/rpc/Utils.js
+/**
+* Buffers writes until `run` replays them with their original contexts and
+* installs the writer. Restores the previous writer when `run` ends.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const withRun = () => (f) => suspend$1(() => {
+	const semaphore = makeUnsafe$5(1);
+	let buffer = [];
+	let write = (...args) => contextWith((context) => {
+		buffer.push([args, context]);
+		return void_;
+	});
+	return map$1(f((...args) => write(...args)), (a) => ({
+		...a,
+		run(f) {
+			return semaphore.withPermits(1)(gen(function* () {
+				const prev = write;
+				for (const [args, context] of buffer) yield* provideContext(suspend$1(() => f(...args)), context);
+				buffer = [];
+				write = f;
+				return yield* onExit(never, () => {
+					write = prev;
+					return void_;
+				});
+			}));
+		}
+	}));
+});
+/**
+* Builds an RPC client protocol service that tracks active client IDs and
+* buffers server responses per client until that client's `run` handler is
+* installed.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const withRunClient = (f) => suspend$1(() => {
+	const clientIds = /* @__PURE__ */ new Set();
+	const clientBuffers = /* @__PURE__ */ new Map();
+	const clientWrites = /* @__PURE__ */ new Map();
+	let write = (clientId, data) => contextWith((context) => {
+		let buffer = clientBuffers.get(clientId);
+		if (!buffer) {
+			buffer = [];
+			clientBuffers.set(clientId, buffer);
+		}
+		buffer.push([data, context]);
+		return void_;
+	});
+	return map$1(f((clientId, data) => {
+		const clientWrite = clientWrites.get(clientId);
+		if (clientWrite) return clientWrite(data);
+		return write(clientId, data);
+	}, clientIds), (a) => ({
+		...a,
+		run(clientId, f) {
+			return gen(function* () {
+				clientIds.add(clientId);
+				clientWrites.set(clientId, f);
+				const buffer = clientBuffers.get(clientId);
+				if (buffer) {
+					clientBuffers.delete(clientId);
+					for (const [args, context] of buffer) yield* provideContext(suspend$1(() => f(args)), context);
+				}
+				return yield* onExit(never, () => {
+					clientIds.delete(clientId);
+					clientWrites.delete(clientId);
+					return void_;
+				});
+			});
+		}
+	}));
+});
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/rpc/RpcClient.js
+const isRpcClientError = (u) => isTagged(u, "RpcClientError");
+let requestIdCounter = 0;
+/**
+* Creates an RPC client for an already-decoded message channel, returning the
+* client API together with a `write` function for delivering server messages
+* back to the client.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const makeNoSerialization = /*#__PURE__*/ fnUntraced(function* (group, options) {
+	const spanPrefix = options.spanPrefix;
+	const supportsAck = options?.supportsAck ?? true;
+	const disableTracing = options?.disableTracing ?? false;
+	const generateRequestId = options?.generateRequestId ?? (() => requestIdCounter++);
+	const services = yield* context();
+	const scope = get(services, Scope);
+	const entries = /* @__PURE__ */ new Map();
+	let isShutdown = false;
+	yield* addFinalizer$1(scope, withFiber((parent) => {
+		isShutdown = true;
+		return clearEntries(interrupt$1(parent.id));
+	}));
+	const clearEntries = fnUntraced(function* (exit) {
+		const pending = Array.from(entries.values());
+		entries.clear();
+		for (const entry of pending) if (entry._tag === "Queue") yield* exit._tag === "Success" ? end(entry.queue) : failCause$2(entry.queue, exit.cause);
+		else entry.resume(exit);
+	}, uninterruptible);
+	const onRequest = (rpc) => {
+		const isStream = isStreamSchema(rpc.successSchema);
+		const middleware = getRpcClientMiddleware(rpc);
+		return (payload, opts) => {
+			const headers = opts?.headers ? fromInput(opts.headers) : empty$2;
+			const context = opts?.context ?? empty();
+			if (!isStream) {
+				const onRequest = (span) => onEffectRequest(rpc, middleware, span, rpc.payloadSchema.make(payload), headers, context, opts?.discard ?? false);
+				return disableTracing ? onRequest(void 0) : useSpan(spanName(spanPrefix, rpc._tag), {
+					kind: "client",
+					attributes: spanAttributes(rpc._tag, options.spanAttributes)
+				}, onRequest);
+			}
+			const queue = onStreamRequest(rpc, middleware, rpc.payloadSchema.make(payload), headers, opts?.streamBufferSize ?? 16, context);
+			if (opts?.asQueue) return queue;
+			return unwrap(map$1(queue, fromQueue));
+		};
+	};
+	const onEffectRequest = (rpc, middleware, span, payload, headers, context, discard) => withFiber((parentFiber) => {
+		if (isShutdown) return interrupt;
+		const id = generateRequestId();
+		const send = middleware((message) => options.onFromClient({
+			message,
+			context
+		}), {
+			_tag: "Request",
+			id,
+			tag: rpc._tag,
+			payload,
+			...span ? {
+				traceId: span.traceId,
+				spanId: span.spanId,
+				sampled: span.sampled
+			} : {},
+			headers: merge$1(parentFiber.getRef(CurrentHeaders), headers),
+			...discard ? { discard: true } : {}
+		});
+		let fiber;
+		return onInterrupt(callback((resume) => {
+			let acked = false;
+			const entry = {
+				_tag: "Effect",
+				rpc,
+				context,
+				resume(exit) {
+					if (discard && exit._tag === "Success") {
+						acked = true;
+						if (fiber?.pollUnsafe()) resume(void_$1);
+						return;
+					}
+					resume(exit);
+					if (fiber && !fiber.pollUnsafe()) parentFiber.currentDispatcher.scheduleTask(() => {
+						fiber.interruptUnsafe(parentFiber.id);
+					}, 0);
+				}
+			};
+			entries.set(id, entry);
+			fiber = send.pipe(span ? withParentSpan(span, { captureStackTrace: false }) : identity, runForkWith(parentFiber.context));
+			fiber.addObserver((exit) => {
+				if (exit._tag === "Failure") {
+					entries.delete(id);
+					return resume(exit);
+				} else if (acked) return resume(void_$1);
+			});
+		}), (interruptors) => {
+			entries.delete(id);
+			return andThen(interrupt$2(fiber), sendInterrupt(id, Array.from(interruptors), context));
+		});
+	});
+	const onStreamRequest = fnUntraced(function* (rpc, middleware, payload, headers, streamBufferSize, context) {
+		if (isShutdown) return yield* interrupt;
+		const span = disableTracing ? void 0 : yield* makeSpanScoped(spanName(spanPrefix, rpc._tag), {
+			kind: "client",
+			attributes: spanAttributes(rpc._tag, options.spanAttributes)
+		});
+		const fiber = getCurrent();
+		const id = generateRequestId();
+		const scope = getUnsafe(fiber.context, Scope);
+		const queue = yield* bounded$1(streamBufferSize);
+		yield* addFinalizerExit(scope, (exit) => {
+			shutdownUnsafe(queue);
+			if (!entries.has(id)) return void_;
+			entries.delete(id);
+			return sendInterrupt(id, isFailure(exit) ? Array.from(interruptors(exit.cause)) : [], context);
+		});
+		entries.set(id, {
+			_tag: "Queue",
+			rpc,
+			queue,
+			scope,
+			context
+		});
+		yield* middleware((message) => options.onFromClient({
+			message,
+			context
+		}), {
+			_tag: "Request",
+			id,
+			tag: rpc._tag,
+			payload,
+			...span ? {
+				traceId: span.traceId,
+				spanId: span.spanId,
+				sampled: span.sampled
+			} : {},
+			headers: merge$1(fiber.getRef(CurrentHeaders), headers)
+		}).pipe(span ? withParentSpan(span, { captureStackTrace: false }) : identity, onError((cause) => {
+			if (!hasInterruptsOnly(cause)) entries.delete(id);
+			return failCause$2(queue, cause);
+		}), interruptible, forkIn(scope, { startImmediately: true }));
+		return queue;
+	});
+	const getRpcClientMiddleware = (rpc) => {
+		const middlewares = [];
+		for (const tag of rpc.middlewares.values()) {
+			const middleware = getOrUndefinedUnsafe(services, `${tag.key}/Client`);
+			if (!middleware) continue;
+			middlewares.push(middleware);
+		}
+		if (middlewares.length === 0) return (send, request) => send(request);
+		return function loop(send, request, index = middlewares.length - 1) {
+			if (index === -1) return send(request);
+			return middlewares[index]({
+				rpc,
+				request,
+				next(request) {
+					return loop(send, request, index - 1);
+				}
+			});
+		};
+	};
+	const sendInterrupt = (requestId, interruptors, context) => callback((resume) => {
+		const parentFiber = getCurrent();
+		options.onFromClient({
+			message: {
+				_tag: "Interrupt",
+				requestId,
+				interruptors
+			},
+			context
+		}).pipe(timeout(1e3), runForkWith(parentFiber.context)).addObserver(() => {
+			resume(void_);
+		});
+	});
+	const write = (message) => {
+		switch (message._tag) {
+			case "Chunk": {
+				const requestId = message.requestId;
+				const entry = entries.get(requestId);
+				if (!entry || entry._tag !== "Queue") return void_;
+				return offerAll(entry.queue, message.values).pipe(supportsAck ? flatMap((dropped) => dropped.length > 0 ? void_ : options.onFromClient({
+					message: {
+						_tag: "Ack",
+						requestId: message.requestId
+					},
+					context: entry.context
+				})) : identity, catchCause((cause) => failCause$2(entry.queue, cause)));
+			}
+			case "Exit": {
+				const requestId = message.requestId;
+				const entry = entries.get(requestId);
+				if (!entry) return void_;
+				entries.delete(requestId);
+				if (entry._tag === "Effect") {
+					entry.resume(message.exit);
+					return void_;
+				}
+				return message.exit._tag === "Success" ? end(entry.queue) : failCause$2(entry.queue, message.exit.cause);
+			}
+			case "Defect": return clearEntries(die$2(message.defect));
+			case "ClientEnd": return void_;
+		}
+	};
+	let client;
+	if (options.flatten) {
+		const fns = /* @__PURE__ */ new Map();
+		client = function client(tag, payload, options) {
+			let fn = fns.get(tag);
+			if (!fn) {
+				fn = onRequest(group.requests.get(tag));
+				fns.set(tag, fn);
+			}
+			return fn(payload, options);
+		};
+	} else {
+		client = {};
+		group.requests.forEach((rpc) => {
+			assignProperty(client, rpc._tag, onRequest(rpc));
+		});
+	}
+	return {
+		client,
+		write
+	};
+});
+let clientIdCounter = 0;
+/**
+* Creates a schema-aware RPC client for a group using the current client
+* `Protocol`, encoding requests and decoding server responses.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make = /*#__PURE__*/ fnUntraced(function* (group, options) {
+	const clientId = clientIdCounter++;
+	const { codecFor, run, send, supportsAck, supportsTransferables } = yield* Protocol;
+	const rpcSchemas = makeRpcSchemas(codecFor);
+	const decodeDefect = decodeSync(codecFor(Defect()));
+	const entries = /* @__PURE__ */ new Map();
+	const closing = makeUnsafe$1();
+	const interruptRequest = (requestId) => {
+		if (!entries.has(requestId)) return void_;
+		entries.delete(requestId);
+		return send(clientId, {
+			_tag: "Interrupt",
+			requestId
+		});
+	};
+	const { client, write } = yield* makeNoSerialization(group, {
+		...options,
+		supportsAck,
+		onFromClient({ message }) {
+			switch (message._tag) {
+				case "Request": {
+					const rpc = group.requests.get(message.tag);
+					const collector = supportsTransferables ? makeCollectorUnsafe() : void 0;
+					const fiber = getCurrent();
+					const entry = {
+						rpc,
+						context: collector ? add(fiber.context, Collector, collector) : fiber.context,
+						schemas: rpcSchemas(rpc),
+						discard: message.discard === true
+					};
+					entries.set(message.id, entry);
+					return entry.schemas.encodePayload(message.payload).pipe(provideContext(entry.context), orDie, flatMap((payload) => {
+						if (isDoneUnsafe(closing)) {
+							entries.delete(message.id);
+							return interrupt;
+						}
+						return send(clientId, {
+							...message,
+							id: message.id,
+							payload,
+							headers: Object.entries(message.headers)
+						}, collector && collector.readUnsafe());
+					}), onError((cause) => hasInterruptsOnly(cause) ? void_ : sync(() => entries.delete(message.id))));
+				}
+				case "Ack":
+					if (!entries.get(message.requestId)) return void_;
+					return send(clientId, {
+						_tag: "Ack",
+						requestId: message.requestId
+					});
+				case "Interrupt": return interruptRequest(message.requestId);
+				case "Eof": return void_;
+			}
+		}
+	});
+	yield* run(clientId, (message) => {
+		switch (message._tag) {
+			case "Chunk": {
+				const requestId = RequestId(message.requestId);
+				const entry = entries.get(requestId);
+				if (!entry || isNone(entry.schemas.decodeChunk)) return void_;
+				const decodeChunk = entry.schemas.decodeChunk.value;
+				return uninterruptibleMask((restore) => restore(decodeChunk(message.values).pipe(provideContext(entry.context), orDie, flatMap((chunk) => write({
+					_tag: "Chunk",
+					clientId: 0,
+					requestId,
+					values: chunk
+				})))).pipe(onError((cause) => write({
+					_tag: "Exit",
+					clientId: 0,
+					requestId,
+					exit: failCause$1(cause)
+				}).pipe(andThen(hasInterrupts(cause) ? void_ : raceFirst(ignore(interruptRequest(requestId)), _await(closing))))), catchCauseIf((cause) => !hasInterrupts(cause), () => void_)));
+			}
+			case "Exit": {
+				const requestId = RequestId(message.requestId);
+				const entry = entries.get(requestId);
+				if (!entry) return void_;
+				entries.delete(requestId);
+				if (entry.discard && message.exit._tag === "Success") return write({
+					_tag: "Exit",
+					clientId: 0,
+					requestId,
+					exit: void_$1
+				});
+				return (entry.discard ? entry.schemas.decodeDiscardExit : entry.schemas.decodeExit)(message.exit).pipe(provideContext(entry.context), orDie, matchCauseEffect({
+					onSuccess: (exit) => write({
+						_tag: "Exit",
+						clientId: 0,
+						requestId,
+						exit
+					}),
+					onFailure: (cause) => write({
+						_tag: "Exit",
+						clientId: 0,
+						requestId,
+						exit: failCause$1(cause)
+					})
+				}));
+			}
+			case "Defect":
+				entries.clear();
+				return write({
+					_tag: "Defect",
+					clientId: 0,
+					defect: decodeDefect(message.defect)
+				});
+			case "ClientProtocolError": {
+				const exit = fail$1(message.error);
+				const requestIds = message.requestIds === void 0 ? Array.from(entries.keys()) : message.requestIds.map(RequestId).filter((requestId) => entries.has(requestId));
+				for (const requestId of requestIds) entries.delete(requestId);
+				return forEach(requestIds, (requestId) => write({
+					_tag: "Exit",
+					clientId: 0,
+					requestId,
+					exit
+				})).pipe(uninterruptible);
+			}
+			default: return void_;
+		}
+	}).pipe(catchCause(logError), interruptible, forkScoped);
+	yield* addFinalizer$2(() => succeed$3(closing, void 0));
+	return client;
+});
+const makeRpcSchemas = (codecFor) => {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (rpc) => {
+		let entry = cache.get(rpc);
+		if (entry !== void 0) return entry;
+		const streamSchemas = getStreamSchemas(rpc.successSchema);
+		const parseOptions = get(rpc.annotations, ParseOptions);
+		const exitSchema$1 = exitSchema(rpc);
+		let decodeDiscardExit;
+		entry = {
+			decodeChunk: map(streamSchemas, (streamSchemas) => decodeUnknownEffect(codecFor(NonEmptyArray(streamSchemas.success)), parseOptions)),
+			encodePayload: encodeEffect(codecFor(rpc.payloadSchema), parseOptions),
+			decodeExit: decodeUnknownEffect(codecFor(exitSchema$1), parseOptions),
+			decodeDiscardExit: (encoded) => (decodeDiscardExit ??= decodeUnknownEffect(codecFor(Exit(Void, exitSchema$1.error, exitSchema$1.defect)), parseOptions))(encoded)
+		};
+		cache.set(rpc, entry);
+		return entry;
+	};
+};
+/**
+* Fiber reference containing headers that are merged into outgoing RPC
+* client requests.
+*
+* **When to use**
+*
+* Use to set request headers that should be automatically merged into outgoing
+* RPC client messages.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const CurrentHeaders = /*#__PURE__*/ Reference("effect/rpc/RpcClient/CurrentHeaders", { defaultValue: () => empty$2 });
+/**
+* Defines the service interface for an RPC client transport, responsible for running the
+* receive loop and sending encoded client messages.
+*
+* **When to use**
+*
+* Use to provide the transport boundary for RPC clients over HTTP, WebSocket,
+* workers, sockets, or custom protocols.
+*
+* **Details**
+*
+* A `Request` that `send` accepts stays pending until a reply names its id: an
+* `Exit`, or a `ClientProtocolError` that lists it in `requestIds`. Until then
+* the client keeps the request and the caller's context, unless the caller is
+* interrupted, the client closes or the connection fails. A transport that
+* only delivers requests, such as a message queue, writes a void `Exit` for a
+* `discard` request once the request is delivered, and fails `send` with an
+* `RpcClientError` for any other request.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+var Protocol = class extends (/*#__PURE__*/ Service$1()("effect/rpc/RpcClient/Protocol")) {
+	/**
+	* Creates a client protocol service from the supplied RPC request runner.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	static make = withRunClient;
+};
+/**
+* Creates a client `Protocol` that sends RPC requests through the supplied
+* `HttpClient` and decodes responses with the current `RpcSerialization`.
+*
+* **Details**
+*
+* Each request is sent as its own HTTP request unless `batch` is set. With
+* `batch`, the first request for a client opens a batch. Requests from the
+* same client made before `window` elapses join it, and the batch is sent once
+* the window elapses or it reaches `maxSize` requests, whichever comes first.
+*
+* @stability unstable
+* @category protocols
+* @since 4.0.0
+*/
+const makeProtocolHttp = (client, options) => options?.batch ? makeProtocolHttpBatched(client, options.batch) : makeProtocolHttpUnbatched(client);
+const makeProtocolHttpUnbatched = (client) => Protocol.make(fnUntraced(function* (writeResponse) {
+	const serialization = yield* RpcSerialization;
+	const exchange = makeHttpExchange(client, serialization, writeResponse);
+	return {
+		send: (clientId, request) => request._tag === "Request" ? flatMap(exchange.send(clientId, [request]), (pending) => exchange.requestExit(request, pending)) : void_,
+		supportsAck: false,
+		supportsTransferables: false,
+		codecFor: serialization.codecFor
+	};
+}));
+const makeProtocolHttpBatched = /*#__PURE__*/ fnUntraced(function* (client, options) {
+	const { maxSize, window } = options;
+	const scopes = /* @__PURE__ */ new Map();
+	const closeScope = (clientId) => {
+		const scope = scopes.get(clientId);
+		if (scope === void 0) return void_;
+		scopes.delete(clientId);
+		return close(scope, void_$1);
+	};
+	const protocol = yield* Protocol.make(fnUntraced(function* (writeResponse) {
+		const serialization = yield* RpcSerialization;
+		const exchange = makeHttpExchange(client, serialization, writeResponse);
+		const batches = /* @__PURE__ */ new Map();
+		const closeBatch = (clientId, batch) => {
+			if (batches.get(clientId) === batch) batches.delete(clientId);
+		};
+		const runBatch = (clientId, batch) => raceFirst(sleep(window), batch.full.await).pipe(andThen(suspend$1(() => {
+			closeBatch(clientId, batch);
+			return exchange.send(clientId, batch.requests);
+		})), onExit((exit) => {
+			closeBatch(clientId, batch);
+			return done(batch.done, exit);
+		}));
+		const send = fnUntraced(function* (clientId, request) {
+			let batch = batches.get(clientId);
+			if (batch === void 0) {
+				batch = {
+					requests: [request],
+					full: makeUnsafe$4(),
+					done: makeUnsafe$1()
+				};
+				batches.set(clientId, batch);
+				let scope = scopes.get(clientId);
+				if (scope === void 0) {
+					scope = makeUnsafe$3();
+					scopes.set(clientId, scope);
+				}
+				yield* forkIn(runBatch(clientId, batch), scope, { startImmediately: true });
+			} else batch.requests.push(request);
+			if (batch.requests.length === maxSize) {
+				closeBatch(clientId, batch);
+				batch.full.openUnsafe();
+			}
+			return yield* exchange.requestExit(request, yield* _await(batch.done));
+		});
+		return {
+			send: (clientId, request) => request._tag === "Request" ? send(clientId, request) : void_,
+			supportsAck: false,
+			supportsTransferables: false,
+			codecFor: serialization.codecFor
+		};
+	}));
+	return Protocol.of({
+		...protocol,
+		run: (clientId, f) => onExit(protocol.run(clientId, f), () => closeScope(clientId))
+	});
+});
+const makeHttpExchange = (client, serialization, writeResponse) => {
+	const isFramed = serialization.includesFraming;
+	const httpClientError = (cause) => new RpcClientError({ reason: HttpClientErrorSchema.fromHttpClientError(cause) });
+	const protocolDefect = (message, cause) => new RpcClientError({ reason: new RpcClientDefect({
+		message,
+		cause
+	}) });
+	const send = fnUntraced(function* (clientId, requests) {
+		const parser = serialization.makeUnsafe();
+		const encoded = parser.encode(requests.length === 1 ? requests[0] : requests);
+		const body = typeof encoded === "string" ? text(encoded, serialization.contentType) : uint8Array(encoded, serialization.contentType);
+		const response = yield* client.post("", { body }).pipe(mapError(httpClientError));
+		const pending = /* @__PURE__ */ new Set();
+		for (let i = 0; i < requests.length; i++) pending.add(String(requests[i].id));
+		const onResponse = (response) => {
+			if (response._tag === "Exit") pending.delete(String(response.requestId));
+			else if (isTerminalResponse(response)) pending.clear();
+			return writeResponse(clientId, response);
+		};
+		if (!isFramed) {
+			const text = yield* response.text.pipe(mapError(httpClientError));
+			const responses = yield* try_({
+				try: () => parser.decode(text),
+				catch: (cause) => protocolDefect("Error decoding HTTP response", cause)
+			});
+			if (!Array.isArray(responses)) return yield* protocolDefect("Expected an array of responses", responses);
+			if (responses.length === 0) return;
+			for (let i = 0; i < responses.length; i++) yield* onResponse(responses[i]);
+			return pending;
+		}
+		let hasResponse = false;
+		yield* runForEachArray(response.stream, (chunk) => try_({
+			try: () => chunk.flatMap(parser.decode),
+			catch: (cause) => protocolDefect("Error decoding HTTP response", cause)
+		}).pipe(flatMap((responses) => {
+			if (responses.length === 0) return void_;
+			hasResponse = true;
+			let i = 0;
+			return whileLoop({
+				while: () => i < responses.length,
+				body: () => onResponse(responses[i++]),
+				step: constVoid
+			});
+		}))).pipe(mapError((cause) => isRpcClientError(cause) ? cause : httpClientError(cause)));
+		return hasResponse ? pending : void 0;
+	});
+	const requestExit = (request, pending) => {
+		if (pending === void 0) return fail$1(protocolDefect("Received empty HTTP response from RPC server", request));
+		else if (pending.has(String(request.id))) return fail$1(protocolDefect("HTTP response ended before RPC request completed", request));
+		return void_$1;
+	};
+	return {
+		send,
+		requestExit
+	};
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/rpc/RpcMiddleware.js
+/**
+* Middleware services for the unstable RPC runtime.
+*
+* A middleware service wraps server handler execution and can also install a
+* client-side wrapper for generated clients. Its metadata records the services
+* provided to downstream handlers, the services required by the middleware
+* implementation, the schema for server-visible failures, the client-only error
+* type, and whether generated clients must require the matching client layer.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
+* The runtime type id used to attach and inspect RPC middleware metadata.
+*
+* @stability unstable
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~effect/rpc/RpcMiddleware";
+/**
+* Creates a typed RPC middleware service class, with optional service
+* requirements, provided services, error schema, and client-side requirement
+* metadata.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const Service = () => (id, options) => {
+	const limit = getStackTraceLimit();
+	let creationError;
+	if (limit !== 0) {
+		setStackTraceLimit(2);
+		creationError = new globalThis.Error();
+		setStackTraceLimit(limit);
+	}
+	function ServiceClass() {}
+	const ServiceClass_ = ServiceClass;
+	Object.setPrototypeOf(ServiceClass, Object.getPrototypeOf(Service$1(id)));
+	ServiceClass.key = id;
+	Object.defineProperty(ServiceClass, "stack", { get() {
+		return creationError?.stack;
+	} });
+	ServiceClass_[TypeId] = TypeId;
+	ServiceClass_.error = options?.error ?? Never;
+	ServiceClass_.requiredForClient = options?.requiredForClient ?? false;
+	return ServiceClass;
+};
+// ../effect/src/contract/actor/actor-already-exists.errors.ts
+var ActorAlreadyExistsError = class extends TaggedError()("ActorAlreadyExistsError", { actor: String$1 }) {};
+// ../effect/src/contract/actor/actor-erased.errors.ts
+var ActorErasedError = class extends TaggedError()("ActorErasedError", { actor: String$1 }) {};
+// ../effect/src/contract/actor/actor-not-created.errors.ts
+var ActorNotCreatedError = class extends TaggedError()("ActorNotCreatedError", { actor: String$1 }) {};
+// ../effect/src/contract/client/actor-unavailable.errors.ts
+var ActorUnavailableError = class extends TaggedError()("ActorUnavailableError", {
+	actor: String$1,
+	message: String$1
+}) {};
+// ../effect/src/contract/caller/caller-not-allowed.errors.ts
+/**
+* The caller's kind may not call this member. Its message names the refused kind and the declaration that admits it,
+* such as `apiKey` for a script, agent or bench signed in with an Akter Cloud API key.
+*/
+var CallerNotAllowedError = class extends TaggedError()("CallerNotAllowedError", {
+	actor: String$1,
+	kind: String$1,
+	member: String$1
+}) {
+	get message() {
+		if (this.member === "akter.files") return `${this.actor}'s files refuse caller kind "${this.kind}". To admit it, list it in the actor's files: Akter.fileAccess({ callers: ["${this.kind}"] }), and allow it in files.authorize.`;
+		if (this.member === "fork") return `${this.actor}.fork refuses caller kind "${this.kind}". Fork admits only an app's operators, the "user" and "apiKey" caller kinds.`;
+		return `${this.actor}.${this.member} refuses caller kind "${this.kind}". To admit it, declare it on the actor, as in callers: { ${this.kind}: Akter.Principal, user: Akter.Principal }, and add "${this.kind}" to the member's callers if it lists them.`;
+	}
+};
+// ../effect/src/contract/caller/unauthenticated.errors.ts
+var UnauthenticatedError = class extends TaggedError()("UnauthenticatedError", { message: String$1 }) {};
+// ../effect/src/contract/command/command-id-expired.errors.ts
+var CommandIdExpiredError = class extends TaggedError()("CommandIdExpiredError", {
+	actor: String$1,
+	commandId: String$1,
+	keptSince: Int,
+	mintedAt: Int
+}) {};
+// ../effect/src/contract/hosted/handler-failed.errors.ts
+/**
+* A handler failed outside its declared error contract. `platform` is true when the failure was Akter's, not the
+* handler's: a platform error such as `FilesUnavailableError` escaped it. Akter Cloud doesn't bill a call that ends
+* with one. A handler's own failure, such as a statement its SQL got wrong, carries no `platform`.
+*/
+var HandlerFailedError = class extends TaggedError()("HandlerFailedError", {
+	actor: String$1,
+	member: String$1,
+	message: String$1,
+	platform: optionalKey(Literal(true))
+}) {};
+// ../effect/src/contract/client/invalid-request.errors.ts
+var InvalidRequestError = class extends TaggedError()("InvalidRequestError", {
+	actor: String$1,
+	message: String$1
+}) {};
+// ../effect/src/contract/spend/billing-unavailable.errors.ts
+/**
+* Akter Cloud couldn't tell whether new spend fits under the caps for too long to admit it safely, so it
+* refused the call. Nothing ran. Retry after `retryAfterSeconds`.
+*/
+var BillingUnavailableError = class extends TaggedError()("BillingUnavailableError", { retryAfterSeconds: Int }) {};
+// ../effect/src/contract/spend/spend-cap-reached.errors.ts
+/**
+* Akter Cloud refused new spend because a spend cap is reached. `scope` says whose cap: the
+* organization's, or the calling API key's. A person raises it in the Cloud API; work already
+* running is not stopped. Amounts are US dollars for the calendar month `period` (`YYYY-MM`), and
+* `spentUsd` includes spend that may still be on its way.
+*/
+var SpendCapReachedError = class extends TaggedError()("SpendCapReachedError", {
+	capUsd: Finite,
+	period: String$1,
+	scope: Literals(["organization", "apiKey"]),
+	spentUsd: Finite
+}) {};
+// ../effect/src/contract/client/storage-limit.errors.ts
+/**
+* Akter Cloud refused a write because the app environment's stored data reached its ceiling: `dataBytes` of
+* `ceilingBytes`, as read from storage at `readAt` (epoch milliseconds). Nothing ran. Queries and downloads still
+* work; a write succeeds again once data is removed or the ceiling is raised.
+*/
+var StorageLimitError = class extends TaggedError()("StorageLimitError", {
+	actor: String$1,
+	ceilingBytes: Finite,
+	dataBytes: Finite,
+	readAt: Int
+}) {};
+// ../effect/src/contract/file/blob-transfer.errors.ts
+var BlobTransferError = class extends TaggedError()("BlobTransferError", {
+	blob: String$1,
+	message: String$1
+}) {};
+TaggedError()("CheckpointExpiredError", { computer: String$1 });
+// ../effect/src/contract/computer/computer-held.errors.ts
+/**
+* A fork holds the computer paused. Nothing but that fork's resume, carrying the same hold, may run or resume it;
+* try again once the fork ends.
+*/
+var ComputerHeldError = class extends TaggedError()("ComputerHeldError", {
+	computer: String$1,
+	hold: String$1
+}) {};
+// ../effect/src/contract/computer/computer-limit.errors.ts
+/**
+* A new computer would pass a limit, so none was made: `store`, the computers one app environment may keep, or
+* `account`, the sandboxes the platform's provider account may run at once. Remove a computer, or try again once
+* one is gone. Nothing waits for room.
+*/
+var ComputerLimitError = class extends TaggedError()("ComputerLimitError", {
+	computer: String$1,
+	limit: Literals(["store", "account"]),
+	maximum: Int
+}) {};
+// ../effect/src/contract/computer/computer-lost.errors.ts
+/**
+* The computer's disk no longer exists, so it can't be resumed or run in. It is not recreated empty under the same
+* name; remove it and ensure it again to start over.
+*/
+var ComputerLostError = class extends TaggedError()("ComputerLostError", { computer: String$1 }) {};
+// ../effect/src/contract/computer/computer-not-found.errors.ts
+/** The actor has no computer of that name. */
+var ComputerNotFoundError = class extends TaggedError()("ComputerNotFoundError", { computer: String$1 }) {};
+// ../effect/src/contract/computer/computers-unavailable.errors.ts
+/** This engine runs no computers, or their provider didn't answer. */
+var ComputersUnavailableError = class extends TaggedError()("ComputersUnavailableError", { message: String$1 }) {};
+// ../effect/src/contract/computer/step/step-not-found.errors.ts
+/** The actor's journal holds no durable step with that key. */
+var StepNotFoundError = class extends TaggedError()("StepNotFoundError", { step: String$1 }) {};
+// ../effect/src/contract/file/access/file-access-denied.errors.ts
+/** The actor's `files.authorize` rule refused this caller's file call. */
+var FileAccessDeniedError = class extends TaggedError()("FileAccessDeniedError", {
+	access: Literals(["read", "write"]),
+	message: String$1,
+	path: String$1
+}) {};
+// ../effect/src/contract/file/file-not-found.errors.ts
+var FileNotFoundError = class extends TaggedError()("FileNotFoundError", { path: String$1 }) {};
+// ../effect/src/contract/file/rpc/file-too-large.errors.ts
+/**
+* An upload would pass the largest file the server accepts, `maximumBytes`, so the chunk was refused and the upload
+* dropped. Nothing was attached. Split the content into smaller files.
+*/
+var FileTooLargeError = class extends TaggedError()("FileTooLargeError", {
+	actor: String$1,
+	maximumBytes: Int
+}) {};
+// ../effect/src/contract/file/files-unavailable.errors.ts
+var FilesUnavailableError = class extends TaggedError()("FilesUnavailableError", { message: String$1 }) {};
+// ../effect/src/contract/file/invalid-file-request.errors.ts
+var InvalidFileRequestError = class extends TaggedError()("InvalidFileRequestError", {
+	message: String$1,
+	path: String$1
+}) {};
+// ../effect/src/contract/secret/invalid-secret-name.errors.ts
+/** An actor declared a secret whose name isn't a `SecretName`, so no environment could ever set it. */
+var InvalidSecretNameError = class extends TaggedError()("InvalidSecretNameError", {
+	actor: String$1,
+	secret: String$1
+}) {};
+// ../effect/src/contract/secret/secret.schema.ts
+const secretNamePattern = /^[A-Z][A-Z0-9_]{0,127}$/u;
+const headerPattern = /^[A-Za-z0-9-]+$/u;
+const printablePattern = /^[\t -~]*$/u;
+/**
+* A secret's name, as Akter Cloud stores it for an environment and as an environment variable: an uppercase letter,
+* then up to 127 uppercase letters, digits or underscores.
+*/
+const SecretName = String$1.check(isPattern(secretNamePattern)).annotate({ description: "A secret's name, as an environment variable." });
+/**
+* Why a secret could not be read:
+*
+* - `undeclared`: the actor doesn't list it in its `secrets`, so it may not read it.
+* - `unset`: the actor declares it, but the environment has no value for it.
+* - `unavailable`: this engine delivers no secrets, or couldn't open them just now.
+* - `command`: a command, query, create or result handler asked; secrets are read in job activities.
+*/
+const SecretRefusal = Literals([
+	"undeclared",
+	"unset",
+	"unavailable",
+	"command"
+]);
+/** What the platform writes before a credential's value, such as `Bearer `: printable ASCII only. */
+const HeaderPrefix = String$1.check(isPattern(printablePattern));
+/** A computer's credential: the secret the platform adds as `header` to its requests to `host`, after `prefix`. */
+const ComputerSecret = Struct({
+	header: String$1.check(isPattern(headerPattern)),
+	host: String$1,
+	prefix: optionalKey(HeaderPrefix),
+	secret: SecretName
+}).annotate({ description: "A credential the platform adds to the computer's requests to one allowed host. The computer never sees its value." });
+// ../effect/src/contract/secret/secret-unavailable.errors.ts
+/** An actor's secret could not be read; `reason` says why (`SecretRefusal`). */
+var SecretUnavailableError = class extends TaggedError()("SecretUnavailableError", {
+	actor: String$1,
+	reason: SecretRefusal,
+	secret: String$1
+}) {};
+// ../effect/src/contract/hosted/hosted-failure.schema.ts
+/**
+* The failures any hosted member can answer besides its declared ones. Akter Cloud's gateway also answers
+* `SpendCapReachedError` and `BillingUnavailableError` when it refuses new spend, and its hosts answer
+* `StorageLimitError` when a write would grow storage past its ceiling, so clients decode those typed.
+*/
+const HostedFailure = Union([
+	ActorErasedError,
+	ActorNotCreatedError,
+	ActorUnavailableError,
+	BillingUnavailableError,
+	CallerNotAllowedError,
+	CommandIdExpiredError,
+	HandlerFailedError,
+	InvalidRequestError,
+	SpendCapReachedError,
+	StorageLimitError
+]);
+// ../effect/src/contract/file/rpc/file-rpc.contract.ts
+/** The largest chunk a download stream sends, and the largest one an upload may append. */
+const fileChunkBytes = 262144;
+const uploadChunkBytes = 1048576;
+const FileRpcFailure = Union([
+	HostedFailure,
+	BlobTransferError,
+	FileAccessDeniedError,
+	FileNotFoundError,
+	FilesUnavailableError,
+	FileTooLargeError,
+	InvalidFileRequestError
+]);
+const WireFileRef = Struct({
+	bytes: Int,
+	path: String$1,
+	sha256: String$1,
+	writtenAt: Int
+});
+const WireFilePage = Struct({
+	cursor: OptionFromNullOr(String$1),
+	entries: ArraySchema(WireFileRef)
+});
+const WireFileUsagePage = Struct({
+	...WireFilePage.fields,
+	bytes: BigIntFromString
+});
+const Listing = {
+	cursor: optionalKey(String$1),
+	key: String$1,
+	limit: optionalKey(Int),
+	prefix: optionalKey(String$1)
+};
+const Chunk = Uint8ArrayFromBase64;
+const fileTag = ({ actor, operation }) => `${actor}/files/${operation}`;
+/**
+* The file streams of one actor, under the tags docs/adr/0016 reserves: `<Actor>/files/<operation>`. Every payload
+* carries the actor's encoded key as a string, as the actor's other RPCs do on the wire. Effect RPC has no client
+* streams, so an upload is a short session: `upload/open` returns an id, `upload/append` sends chunks of at most
+* 1 MiB in order and is idempotent by offset, and `upload/close` checks the length and returns the receipt a command
+* attaches. A download streams chunks of at most 256 KiB.
+*/
+const fileRpcsOf = (actor) => [
+	make$2(fileTag({
+		actor,
+		operation: "list"
+	}), {
+		error: FileRpcFailure,
+		payload: Listing,
+		success: WireFilePage
+	}),
+	make$2(fileTag({
+		actor,
+		operation: "usage"
+	}), {
+		error: FileRpcFailure,
+		payload: Listing,
+		success: WireFileUsagePage
+	}),
+	make$2(fileTag({
+		actor,
+		operation: "download"
+	}), {
+		error: FileRpcFailure,
+		payload: {
+			key: String$1,
+			length: optionalKey(Int),
+			offset: optionalKey(Int),
+			path: String$1
+		},
+		stream: true,
+		success: Chunk
+	}),
+	make$2(fileTag({
+		actor,
+		operation: "upload/open"
+	}), {
+		error: FileRpcFailure,
+		payload: { key: String$1 },
+		success: Struct({ upload: String$1 })
+	}),
+	make$2(fileTag({
+		actor,
+		operation: "upload/append"
+	}), {
+		error: FileRpcFailure,
+		payload: {
+			bytes: Chunk,
+			key: String$1,
+			offset: Int,
+			upload: String$1
+		},
+		success: Struct({ received: Int })
+	}),
+	make$2(fileTag({
+		actor,
+		operation: "upload/close"
+	}), {
+		error: FileRpcFailure,
+		payload: {
+			bytes: Int,
+			key: String$1,
+			upload: String$1
+		},
+		success: Struct({ receipt: String$1 })
+	})
+];
+// ../effect/src/contract/command/command-id.schema.ts
+const CommandId = String$1.pipe(brand("CommandId"));
+// ../effect/src/contract/fork/fork-rpc.contract.ts
+/** What a fork answers: the parent's commit version at the cut the child was copied from. */
+const Forked = Struct({ version: Int });
+const ForkFailure = Union([HostedFailure, ActorAlreadyExistsError]);
+const forkTag = (actor) => `${actor}/fork`;
+/**
+* Forks one actor under the tag docs/adr/0016 reserves: `<Actor>/fork` copies the actor at `key`, at one cut between
+* two of its commands, into a new actor of the same kind at `into` (ADR 0017, ADR 0018). The copy starts quiet, with
+* its own key, and nothing reads it before it is whole. `commandId` names the fork, so a retry with it answers the
+* same fork instead of making a second copy.
+*/
+const forkRpcOf = ({ actor, key }) => make$2(forkTag(actor), {
+	error: ForkFailure,
+	payload: {
+		commandId: CommandId,
+		into: key,
+		key
+	},
+	success: Forked
+});
+// ../effect/src/contract/computer/files/computer-files.schema.ts
+/** One file per call, bounded before crossing the host/control link. Paths are relative to the computer's files directory. */
+const computerFileBytes = 1048576;
+const ComputerFileRequest = TaggedUnion({
+	Read: { path: String$1 },
+	Write: {
+		content: Uint8ArrayFromBase64,
+		path: String$1
+	}
+});
+const ComputerCopy = Struct({
+	computer: String$1,
+	computerPath: String$1,
+	direction: Literals(["toComputer", "fromComputer"]),
+	key: String$1,
+	path: String$1
+});
+/** Copy-back returns an upload receipt; only an actor command can attach it to an actor path. */
+const ComputerCopyResult = Struct({
+	bytes: Int,
+	receipt: optionalKey(String$1)
+});
+// ../effect/src/contract/computer/computer.schema.ts
+const kib = 1024;
+const mib = kib * kib;
+const inputKib = 100;
+const outputMib = 4;
+const smallest$1 = 1;
+const nothing = 0;
+/**
+* Archil's serverless exec limits, applied to every exec step so a step behaves the same in any engine: five
+* minutes, 100 KiB of command and standard input together, and 4 MiB of each output stream returned. Longer work
+* runs as a process in the computer; longer output belongs in files.
+*/
+const execLimits = {
+	inputBytes: inputKib * kib,
+	outputBytes: outputMib * mib,
+	seconds: 300
+};
+const encoder = new globalThis.TextEncoder();
+/** One of an actor's computers. Lowercase letters, digits and hyphens, starting with a letter. */
+const ComputerName = String$1.check(isPattern(new RegExp(`^[a-z][a-z0-9-]{0,62}$`, "u"))).pipe(brand("ComputerName")).annotate({ description: "A computer's name, unique among its actor's computers." });
+const Seconds = Int.check(isBetween({
+	maximum: execLimits.seconds,
+	minimum: smallest$1
+}));
+const Positive = Int.check(isGreaterThanOrEqualTo(smallest$1));
+const ComputerSize = Struct({
+	memoryMib: Positive,
+	vcpu: Positive
+});
+/**
+* A computer to keep: its image, its size and the hosts it may reach. `egress` lists hosts or rules, never
+* credentials. `secrets` names the credentials the platform adds to an allowed host's requests on the way out, from
+* the actor's declared secrets, so no value ever reaches the computer.
+*/
+const ComputerSpec = Struct({
+	egress: ArraySchema(String$1),
+	image: String$1,
+	name: ComputerName,
+	secrets: optionalKey(ArraySchema(ComputerSecret)),
+	size: ComputerSize
+});
+/**
+* Where a computer is. `paused` keeps its memory, processes and files; `stopped` and `failed` keep only its files;
+* `gone` means its disk no longer exists, so it is never recreated empty under the same name by accident.
+*/
+const ComputerState = Literals([
+	"starting",
+	"running",
+	"paused",
+	"stopped",
+	"failed",
+	"gone"
+]);
+const Computer = Struct({
+	...ComputerSpec.fields,
+	state: ComputerState
+});
+const withinInput = makeFilter((request) => encoder.encode(request.command).byteLength + (request.stdin?.byteLength ?? nothing) <= execLimits.inputBytes, { expected: `a command and standard input of at most ${execLimits.inputBytes} bytes together` });
+/**
+* One exec step. `key` is the step's stable logical-operation key, such as `Activity.idempotencyKey(name)`: the
+* computer records the outcome under it, so the same step sent again reads that outcome back instead of running.
+*/
+const ExecRequest = Struct({
+	command: String$1,
+	cwd: optionalKey(String$1),
+	key: String$1.check(isMinLength(smallest$1)),
+	stdin: optionalKey(Uint8Array$1),
+	timeoutSeconds: optionalKey(Seconds)
+}).check(withinInput);
+/**
+* The step ran to an end, or its recorded outcome was read back; the two look the same. `exitCode` is absent when
+* the process was ended without one, such as at the time limit. Past 4 MiB a stream, output is not returned and
+* `truncated` is set; the whole of each stream stays in the step's directory on the computer.
+*/
+const ExecRan = TaggedStruct("Ran", {
+	exitCode: optionalKey(Int),
+	stderr: String$1,
+	stdout: String$1,
+	truncated: Boolean
+});
+/**
+* The step started once but no outcome was recorded: the computer lost power, or the step is still running. It is
+* not run again, because whatever it did outside the computer may already have happened. Reconcile with the
+* outside system by the step's key.
+*/
+const ExecUnknown = TaggedStruct("Unknown", {});
+const ExecResult = Union([ExecRan, ExecUnknown]);
+/** How much a log page returns at most, and when a request names no limit. */
+const logPageLines = 1e3;
+/**
+* One line of a computer's log, oldest first: what the platform did to it (made, paused, resumed, stopped, forked,
+* deleted) and each exec step's key and outcome. `seq` rises by one per line of the computer, so a reader passes the
+* last `seq` it saw as `after` to read on.
+*/
+const ComputerLogLine = Struct({
+	at: Int,
+	level: Literals([
+		"info",
+		"warn",
+		"error"
+	]),
+	message: String$1,
+	seq: Int
+});
+const LogLimit = Int.check(isBetween({
+	maximum: logPageLines,
+	minimum: smallest$1
+}));
+/** A page of a computer's log: the lines after `after`, at most `limit` (1 to 1,000; 1,000 when absent). */
+const ComputerLogPage = Struct({
+	after: optionalKey(Int),
+	limit: optionalKey(LogLimit)
+});
+// ../effect/src/contract/computer/step/computer-step.schema.ts
+const smallest = 1;
+const largestPage = 1e3;
+/** A step's name, unique among its job's steps: lowercase letters, digits, dots, underscores and hyphens. */
+const StepName = String$1.check(isPattern(new RegExp(`^[a-z0-9][a-z0-9._-]{0,62}$`, "u"))).annotate({ description: "A step's name, unique among its job's steps." });
+const { command, cwd, stdin, timeoutSeconds } = ExecRequest.fields;
+/**
+* One durable step of a job (`step` on an actor's computers): the exec request without its key, which the step derives from its job and
+* name, so the same step in a replayed job sends the same key.
+*/
+const StepRequest = Struct({
+	command,
+	cwd,
+	name: StepName,
+	stdin,
+	timeoutSeconds
+});
+/** What a step journals before it sends anything: where it runs, its key, and when it first started. */
+const StepStart = Struct({
+	command: String$1,
+	computer: String$1,
+	key: String$1,
+	startedAt: Int,
+	timeoutSeconds: Int
+});
+/** What a step journals once it settles: its outcome, and when it settled. */
+const StepEnd = Struct({
+	endedAt: Int,
+	outcome: ExecResult
+});
+/**
+* Where a step is. `running` has no outcome yet; `ran` ended with its exit code and output; `unknown` started and has no
+* recorded outcome, so it may or may not have done its work, and is never run again; `failed` could not run, such as on
+* a lost computer.
+*/
+const StepState = Literals([
+	"running",
+	"ran",
+	"unknown",
+	"failed"
+]);
+/**
+* One step as the actor's journal holds it. `step` is its key, the id a reader asks for it by and the key an outside
+* system reconciles an `unknown` step with. Output is only in a single step's read.
+*/
+const ComputerStep = Struct({
+	command: String$1,
+	computer: String$1,
+	endedAt: optionalKey(Int),
+	exitCode: optionalKey(Int),
+	failure: optionalKey(String$1),
+	job: String$1,
+	name: String$1,
+	startedAt: Int,
+	state: StepState,
+	stderr: optionalKey(String$1),
+	stdout: optionalKey(String$1),
+	step: String$1,
+	timeoutSeconds: Int,
+	truncated: optionalKey(Boolean)
+});
+const StepLimit = Int.check(isBetween({
+	maximum: largestPage,
+	minimum: smallest
+}));
+/** A page of an actor's steps, newest first: at most `limit` (1 to 1,000; 100 when absent). */
+const StepPage = Struct({ limit: optionalKey(StepLimit) });
+// ../effect/src/contract/computer/rpc/computer-rpc.contract.ts
+const ComputerRpcFailure = Union([
+	HostedFailure,
+	ComputerHeldError,
+	ComputerLostError,
+	ComputerNotFoundError,
+	ComputersUnavailableError,
+	StepNotFoundError
+]);
+/** The actor's encoded key, as every actor RPC carries it. */
+const Keyed = { key: String$1 };
+/** One computer of the actor, by name. */
+const Named = {
+	computer: String$1,
+	key: String$1
+};
+const Logs = {
+	...Named,
+	...ComputerLogPage.fields
+};
+/** A page of the actor's durable steps. */
+const Paged = {
+	...Keyed,
+	...StepPage.fields
+};
+/** One durable step of the actor, by its key. */
+const Stepped = {
+	key: String$1,
+	step: String$1
+};
+const Computers = ArraySchema(Computer);
+const Steps = ArraySchema(ComputerStep);
+const LogLines = ArraySchema(ComputerLogLine);
+const computerTag = ({ actor, operation }) => `${actor}/computer/${operation}`;
+const named = (actor, operation) => make$2(computerTag({
+	actor,
+	operation
+}), {
+	error: ComputerRpcFailure,
+	payload: Named,
+	success: Computer
+});
+/**
+* An actor's computers as seen from outside the actor, under the tags docs/adr/0016 reserves:
+* `<Actor>/computer/<operation>`. Every payload carries the actor's encoded key. `list` and `get` answer computers as
+* they are; `pause`, `resume` and `stop` drive one there and answer it, and a `resume` of a computer a fork holds
+* fails with `ComputerHeldError`; `delete` removes one with its disk and answers nothing, so a client confirms it
+* first; `logs` reads a page of its log. There is no outside `exec` and no `ensure`: only the actor makes and runs
+* its computers. `steps` reads a page of the actor's durable steps, newest first, and `step` one step by its key with its
+* output (`StepNotFoundError` when the journal has none); both read the actor's own journal, not a computer.
+*/
+const computerRpcsOf = (actor) => [
+	make$2(computerTag({
+		actor,
+		operation: "files"
+	}), {
+		error: ComputerRpcFailure,
+		payload: ComputerCopy,
+		success: ComputerCopyResult
+	}),
+	make$2(computerTag({
+		actor,
+		operation: "list"
+	}), {
+		error: ComputerRpcFailure,
+		payload: Keyed,
+		success: Computers
+	}),
+	named(actor, "get"),
+	named(actor, "pause"),
+	named(actor, "resume"),
+	named(actor, "stop"),
+	make$2(computerTag({
+		actor,
+		operation: "delete"
+	}), {
+		error: ComputerRpcFailure,
+		payload: Named,
+		success: Void
+	}),
+	make$2(computerTag({
+		actor,
+		operation: "logs"
+	}), {
+		error: ComputerRpcFailure,
+		payload: Logs,
+		success: LogLines
+	}),
+	make$2(computerTag({
+		actor,
+		operation: "steps"
+	}), {
+		error: ComputerRpcFailure,
+		payload: Paged,
+		success: Steps
+	}),
+	make$2(computerTag({
+		actor,
+		operation: "step"
+	}), {
+		error: ComputerRpcFailure,
+		payload: Stepped,
+		success: ComputerStep
+	})
+];
+// ../effect/src/contract/client/actor-rpc.contract.ts
+const creationModes = ["create", "ensure"];
+const creationErrors = {
+	create: ActorAlreadyExistsError,
+	ensure: Never
+};
+const creationModesOf = (create) => {
+	if (isNever(create.ast)) return [];
+	return creationModes;
+};
+// ../effect/src/contract/caller/authentication.api.ts
+var Authentication = class extends Service()("@akterjs/effect/contract/caller/authentication.api/Authentication", { error: UnauthenticatedError }) {};
+// ../effect/src/contract/computer/step/step-failure.schema.ts
+/** Every failure a computer client can answer, as a schema, so a step journals the one it settled with. */
+const StepFailure = Union([
+	ActorUnavailableError,
+	CallerNotAllowedError,
+	ComputerHeldError,
+	ComputerLimitError,
+	ComputerLostError,
+	ComputerNotFoundError,
+	ComputersUnavailableError,
+	InvalidRequestError,
+	UnauthenticatedError
+]);
+// ../effect/src/contract/computer/step/computer-step.contract.ts
+/**
+* How long past its own time limit a step keeps asking for its outcome, measured from when it was first journaled: the
+* time between journaling and the computer starting the command, which a lost reply or a restart can stretch.
+*/
+const graceSeconds = 10;
+/** How often a step asks again while its computer is unreachable or its command has no outcome yet. */
+const askEverySeconds = 2;
+const millis = 1e3;
+const none = 0;
+/** The step was sent before and its command has no recorded outcome yet: it may still be running. */
+var NoOutcomeYetError = class extends TaggedError()("NoOutcomeYetError", {}) {};
+/** Failures that say nothing about the step: the engine or control plane between the job and the computer is away. */
+const isPassing = is(Union([
+	ActorUnavailableError,
+	ComputersUnavailableError,
+	NoOutcomeYetError
+]));
+const isRan = is(ExecRan);
+const sentOnce = (client, request, start) => {
+	const sent = client.exec(start.computer, {
+		...omit(request, ["name"]),
+		key: start.key,
+		timeoutSeconds: start.timeoutSeconds
+	});
+	return filterOrFail(sent, isRan, () => NoOutcomeYetError.make({}));
+};
+/**
+* Sends the step under its key until it has an outcome, asking again while its computer is unreachable or its command
+* runs on past a lost reply, until its time limit and the grace have passed since it was first journaled. The key
+* makes every send after the first read the command's outcome back instead of running it again. Past the deadline with
+* no outcome the step is `Unknown`: it may have done its work, and it never runs again.
+*/
+const settled = (client, request, start) => gen(function* settledStep() {
+	const now = yield* currentTimeMillis;
+	const deadline = start.startedAt + (start.timeoutSeconds + graceSeconds) * millis;
+	const remaining = millis$1(Math.max(none, deadline - now));
+	const asking = spaced(seconds(askEverySeconds)).pipe(upTo({ duration: remaining }));
+	const outcome = yield* sentOnce(client, request, start).pipe(retry({
+		schedule: asking,
+		while: isPassing
+	}), catchIf(isPassing, () => succeed(ExecUnknown.make({}))));
+	return {
+		endedAt: yield* currentTimeMillis,
+		outcome
+	};
+});
+const started = (computer, request) => gen(function* startedStep() {
+	const key = yield* idempotencyKey(`step/${request.name}`);
+	const startedAt = yield* currentTimeMillis;
+	const timeoutSeconds = request.timeoutSeconds ?? execLimits.seconds;
+	return {
+		command: request.command,
+		computer,
+		key,
+		startedAt,
+		timeoutSeconds
+	};
+});
+/**
+* Runs one command in one of the actor's computers as a durable step of the job that calls it, and answers its
+* outcome. The step journals where it runs, its key and when it started before it sends anything, then its outcome,
+* so `akter steps` reads it from the actor. A job replayed after a host or control plane restart reads both back: a
+* settled step answers its journaled outcome without reaching the computer, and a step cut off mid-flight sends the
+* same key again, which reads the command's own recorded outcome back and never runs it a second time. A command whose
+* outcome no send could read before its deadline answers `Unknown`; reconcile it with the outside system by its key.
+* Call it from a job, never from inside an activity, and give each step of a job its own name.
+*/
+const step = ({ client, computer, request }) => gen(function* durableStep() {
+	const start = yield* make$4({
+		execute: started(computer, request),
+		name: `step-start/${request.name}`,
+		success: StepStart
+	});
+	return (yield* make$4({
+		error: StepFailure,
+		execute: settled(client, request, start),
+		name: `step/${request.name}`,
+		success: StepEnd
+	})).outcome;
+});
+// ../effect/src/contract/computer/computer-client.adapter.ts
+const checked = (schema, actor) => {
+	const decode = decodeUnknownEffect(schema);
+	return (value) => mapError(decode(value), (invalid) => InvalidRequestError.make({
+		actor,
+		message: invalid.message
+	}));
+};
+/** A spec binds only secrets the actor declares, so a computer never gets a credential its actor may not read. */
+const declared = ({ definition, name }) => (spec) => {
+	const undeclared = findFirst(spec.secrets ?? [], ({ secret }) => !contains(definition.secrets, secret));
+	return match(undeclared, {
+		onNone: () => succeed(spec),
+		onSome: ({ secret }) => fail(SecretUnavailableError.make({
+			actor: name,
+			reason: "undeclared",
+			secret
+		}))
+	});
+};
+/**
+* Checks every spec and exec request against the contract, so an engine never sees one past the limits, and every
+* secret a spec binds against the actor's declaration.
+*/
+const bounded = (client, source) => {
+	const spec = checked(ComputerSpec, source.name);
+	const request = checked(ExecRequest, source.name);
+	const allowed = declared(source);
+	const stepRequest = checked(StepRequest, source.name);
+	const checkedClient = {
+		...client,
+		ensure: (wanted) => flatMap(flatMap(spec(wanted), allowed), client.ensure),
+		exec: (computer, wanted) => flatMap(request(wanted), (valid) => client.exec(computer, valid))
+	};
+	return {
+		...checkedClient,
+		step: (computer, wanted) => flatMap(stepRequest(wanted), (valid) => step({
+			client: checkedClient,
+			computer,
+			request: valid
+		}))
+	};
+};
+var ActorComputerClients = class ActorComputerClients extends Service$1()("@akterjs/effect/contract/computer/computer-client.adapter/ActorComputerClients") {
+	static clientOf({ definition, name }) {
+		return (key) => gen(function* connectComputers() {
+			const clients = yield* serviceOption(ActorComputerClients);
+			if (isNone(clients)) return yield* ComputersUnavailableError.make({ message: "computers aren't available on this host" });
+			const encoded = yield* encodeEffect(definition.key)(key).pipe(mapError(() => InvalidRequestError.make({
+				actor: name,
+				message: "the actor key is invalid"
+			})));
+			return bounded(clients.value.connect({
+				actor: name,
+				key: encoded
+			}), {
+				definition,
+				name
+			});
+		});
+	}
+};
+// ../effect/src/contract/state/actor-state.service.ts
+var ActorState = class ActorState extends Service$1()("@akterjs/effect/contract/state/actor-state.service/ActorState") {
+	static files({ files, now }) {
+		return {
+			attach: (path, receipt) => ActorState.use((state) => flatMap(now, (at) => state.attachFile({
+				now: at,
+				path,
+				receipt
+			}))),
+			fileUsage: files.fileUsage,
+			list: files.list,
+			read: files.read,
+			remove: (path) => ActorState.use((state) => state.removeFile(path))
+		};
+	}
+};
+// ../effect/src/contract/secret/actor-secrets.adapter.ts
+const refused = (reason) => ({ actor, secret }) => SecretUnavailableError.make({
+	actor,
+	reason,
+	secret
+});
+/** Reads each secret by its own name through `provider`: the process environment by default. */
+const fromProvider = (provider) => (request) => option(Redacted(request.secret)).pipe(provideService(ConfigProvider, provider), mapError(() => refused("unavailable")(request)), flatMap((found) => mapError(fromOption(found), () => refused("unset")(request))));
+/**
+* Where an engine's actors read their secrets. A host provides it to the app's job runtime, so job activities reach
+* it through `Actor.secret(name)`. Nothing else asks it directly: `Actor.secret` checks the declaration first.
+*/
+var ActorSecrets = class ActorSecrets extends Service$1()("@akterjs/effect/contract/secret/actor-secrets.adapter/ActorSecrets") {
+	/**
+	* Secrets from the `ConfigProvider` current when it is built, each under its own name. `Akter.jobs` and `Story.run`
+	* provide it, so `akter dev` and scripts read the process environment (Bun loads `.env`), and a test builds them
+	* under a `ConfigProvider` of its own.
+	*/
+	static fromConfig = effect(this, map$1(ConfigProvider, (provider) => ({ read: fromProvider(provider) })));
+	static secretOf({ name, secrets: declared }) {
+		return (secret) => gen(function* readSecret() {
+			const request = {
+				actor: name,
+				secret
+			};
+			if (!contains(declared, secret)) return yield* refused("undeclared")(request);
+			const handler = yield* serviceOption(ActorState);
+			if (isSome(handler)) return yield* refused("command")(request);
+			const secrets = yield* serviceOption(ActorSecrets);
+			if (isNone(secrets)) return yield* refused("unavailable")(request);
+			return yield* secrets.value.read(request);
+		});
+	}
+};
+// ../effect/src/contract/file/file-client.adapter.ts
+var ActorFileClients = class ActorFileClients extends Service$1()("@akterjs/effect/contract/file/file-client.adapter/ActorFileClients") {
+	static clientOf({ definition, name }) {
+		return (key) => gen(function* connectFiles() {
+			const clients = yield* serviceOption(ActorFileClients);
+			if (isNone(clients)) return yield* FilesUnavailableError.make({ message: "files aren't available on this host" });
+			const encoded = yield* encodeEffect(definition.key)(key).pipe(mapError(() => InvalidRequestError.make({
+				actor: name,
+				message: "the actor key is invalid"
+			})));
+			return clients.value.connect({
+				actor: name,
+				key: encoded
+			});
+		});
+	}
+};
+// ../effect/src/contract/client/actor-client.adapter.ts
+const retryMillis = 50;
+const retryLimit = 5;
+const resumeCapMillis = 5e3;
+const noVersion = -1;
+const isTransportFailure = (failure) => isTagged(failure, "RpcClientError");
+const resubscribing = min([exponential(millis$1(retryMillis)), spaced(millis$1(resumeCapMillis))]).pipe(while_(({ input }) => isTransportFailure(input)));
+const resumed = (updates) => updates.pipe(retry$1(resubscribing), mapAccum(() => noVersion, (last, update) => {
+	if (update.version > last) return [update.version, [update]];
+	return [last, []];
+}));
+function wireSenders(rpcs) {
+	return map$1(make(rpcs, { flatten: true }), (client) => ({
+		send: client,
+		watch: client
+	}));
+}
+const sendOnce = ({ random, senders }, tag, request) => flatMap(random.uuidV7(), (commandId) => retry(senders.send(tag, {
+	...request,
+	commandId
+}), {
+	schedule: exponential(millis$1(retryMillis)),
+	times: retryLimit,
+	while: isTransportFailure
+}));
+const queriesOf = ({ senders, source }, key) => map$3(source.definition.queries, (_declaration, member) => {
+	const call = (payload) => senders.send(`${source.name}/${member}`, {
+		key,
+		payload
+	});
+	return Object.assign(call, { subscribe: (payload) => resumed(senders.watch(`${source.name}/${member}/subscribe`, {
+		key,
+		payload
+	})) });
+});
+const wireClient = (wiring, key) => {
+	const { definition, name } = wiring.source;
+	const { send, watch } = wiring.senders;
+	const command = (tag) => (payload) => sendOnce(wiring, tag, {
+		key,
+		payload
+	});
+	const creation = fromEntries(map$2(creationModesOf(definition.create), (mode) => [mode, command(`${name}/${mode}`)]));
+	const fork = (into) => as(sendOnce(wiring, `${name}/fork`, {
+		into,
+		key
+	}), wireClient(wiring, into));
+	return {
+		...map$3(definition.commands, (_declaration, member) => command(`${name}/${member}`)),
+		...creation,
+		...queriesOf(wiring, key),
+		fork,
+		state: resumed(watch(`${name}/state/subscribe`, { key })),
+		warm: send(`${name}/warm`, { key })
+	};
+};
+var ActorClients = class ActorClients extends Service$1()("@akterjs/effect/contract/client/actor-client.adapter/ActorClients") {
+	static computerOf(source) {
+		return ActorComputerClients.clientOf(source);
+	}
+	static filesOf(source) {
+		return ActorFileClients.clientOf(source);
+	}
+	/** The actor's declared secrets, read in its job activities (`ActorSecrets`). */
+	static secretOf(source) {
+		return ActorSecrets.secretOf({
+			name: source.name,
+			secrets: source.definition.secrets
+		});
+	}
+	static layer = effect(ActorClients, gen(function* makeActorClients() {
+		const random = yield* SecureRandom;
+		return { connect: (source, key) => map$1(wireSenders(source.rpcs), (senders) => wireClient({
+			random,
+			senders,
+			source
+		}, key)) };
+	}));
+	static clientOf(source) {
+		return (key) => ActorClients.use((clients) => clients.connect(source, key));
+	}
+};
+export { ActorAlreadyExistsError as $, SecretName as A, SuspendOnFailure as At, ComputerLostError as B, CommandId as C, isWrapper as Ct, uploadChunkBytes as D, isStreamSchema as Dt, fileTag as E, getStreamSchemas as Et, FileNotFoundError as F, wrapActivityResult as Ft, InvalidRequestError as G, ComputerHeldError as H, FileAccessDeniedError as I, make$6 as It, UnauthenticatedError as J, HandlerFailedError as K, StepNotFoundError as L, remove as Lt, InvalidFileRequestError as M, intoResult as Mt, FilesUnavailableError as N, make$5 as Nt, HostedFailure as O, fromWebSocket as Ot, FileTooLargeError as P, suspend as Pt, ActorErasedError as Q, ComputersUnavailableError as R, run as Rt, forkRpcOf as S, exitSchema as St, fileRpcsOf as T, ClientAbort as Tt, BlobTransferError as U, ComputerLimitError as V, StorageLimitError as W, ActorUnavailableError as X, CallerNotAllowedError as Y, ActorNotCreatedError as Z, ExecUnknown as _, Collector as _t, ActorComputerClients as a, json as at, ComputerFileRequest as b, ParseOptions as bt, creationModesOf as c, ResponseDefectEncoded as ct, StepEnd as d, constPong as dt, Protocol as et, StepStart as f, isTerminalResponse as ft, ExecRan as g, spanName as gt, ComputerSpec as h, spanAttributes as ht, ActorState as i, RpcSerialization as it, InvalidSecretNameError as j, Suspended as jt, SecretUnavailableError as k, Complete as kt, computerRpcsOf as l, constEof as lt, ComputerLogLine as m, RpcClientError as mt, ActorFileClients as n, makeProtocolHttp as nt, Authentication as o, layerNdjson as ot, largestPage as p, RpcClientDefect as pt, CommandIdExpiredError as q, ActorSecrets as r, withRun as rt, creationErrors as s, RequestId as st, ActorClients as t, make as tt, computerTag as u, constPing as ut, execLimits as v, makeCollectorUnsafe as vt, fileChunkBytes as w, make$2 as wt, computerFileBytes as x, ServerClient as xt, logPageLines as y, make$1 as yt, ComputerNotFoundError as z };