@kitman-sh/cli 0.0.0-stage → 0.7.0

package/dist/chunk-dwgta18y.js

@@ -0,0 +1,1178 @@
+// @bun
+import {
+  dual,
+  identity,
+  constVoid,
+  flow,
+  hasProperty,
+  assignProperty,
+  isNone,
+  isSome,
+  map,
+  Service,
+  empty,
+  add,
+  getOrUndefinedUnsafe,
+  getUnsafe,
+  get,
+  merge,
+  Reference,
+  isSuccess,
+  toMillis,
+  squash,
+  findError,
+  hasInterrupts,
+  interruptors,
+  failCause,
+  fail2,
+  die2,
+  interrupt,
+  isFailure2,
+  Scope,
+  provide,
+  addFinalizerExit,
+  addFinalizer,
+  succeed4,
+  effect,
+  Clock,
+  min,
+  exponential,
+  spaced,
+  forEach,
+  whileLoop,
+  succeed5,
+  suspend,
+  sync,
+  void_2,
+  callback,
+  never,
+  gen,
+  fail4,
+  withFiber,
+  flatMap,
+  andThen,
+  map3,
+  catchCause,
+  catchCauseIf,
+  orDie,
+  tapCause,
+  retryOrElse,
+  ignore,
+  ignoreCause,
+  timeout,
+  timeoutOrElse,
+  delay,
+  raceFirst,
+  matchCauseEffect,
+  context,
+  contextWith,
+  provideContext,
+  serviceOption,
+  updateContext,
+  updateService,
+  scope,
+  scoped,
+  acquireRelease,
+  ensuring,
+  onError,
+  onExit,
+  interrupt2,
+  interruptible,
+  onInterrupt,
+  uninterruptibleMask,
+  forever,
+  makeSpanScoped,
+  useSpan,
+  withParentSpan,
+  forkIn,
+  forkScoped,
+  runForkWith,
+  fnUntraced,
+  logError,
+  annotateLogs,
+  interrupt3,
+  getCurrent,
+  makeUnsafe3,
+  bounded,
+  offerAll,
+  failCause3,
+  end,
+  shutdownUnsafe,
+  fromQueue,
+  unwrap,
+  empty3,
+  fromInput,
+  merge3,
+  decodeUnknownEffect,
+  decodeSync,
+  encodeEffect,
+  optional,
+  String2,
+  NonEmptyArray,
+  Union,
+  Literals,
+  tag,
+  Int,
+  Defect,
+  Error2,
+  TaggedError2,
+  toCodecJson,
+  HttpClientErrorSchema,
+  isStreamSchema,
+  getStreamSchemas,
+  exitSchema
+} from "./chunk-704ws2q7.js";
+
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/socket/Socket.js
+var TypeId = "~effect/socket/Socket";
+var Socket = /* @__PURE__ */ Service("effect/socket/Socket");
+var make4 = (options) => Socket.of({
+  [TypeId]: TypeId,
+  reader: options.reader,
+  writer: options.writer
+});
+var encoder = /* @__PURE__ */ new TextEncoder;
+var readerString = (self, encoding) => map3(self.reader, ({
+  pull
+}) => {
+  const decoder = new TextDecoder(encoding);
+  return map3(pull, (chunk) => {
+    const out = new Array(chunk.length);
+    for (let i = 0;i < chunk.length; i++) {
+      const item = chunk[i];
+      out[i] = typeof item === "string" ? item : decoder.decode(item);
+    }
+    return out;
+  });
+});
+var CloseEventTypeId = "~effect/socket/Socket/CloseEvent";
+var isCloseEvent = (u) => hasProperty(u, CloseEventTypeId);
+var SocketErrorTypeId = "~effect/socket/Socket/SocketError";
+var isSocketError = (u) => hasProperty(u, SocketErrorTypeId);
+
+class SocketReadError extends (/* @__PURE__ */ Error2("effect/socket/Socket/SocketReadError")({
+  _tag: /* @__PURE__ */ tag("SocketReadError"),
+  cause: /* @__PURE__ */ Defect()
+})) {
+  message = `An error occurred during Read`;
+}
+
+class SocketWriteError extends (/* @__PURE__ */ Error2("effect/socket/Socket/SocketWriteError")({
+  _tag: /* @__PURE__ */ tag("SocketWriteError"),
+  cause: /* @__PURE__ */ Defect()
+})) {
+  message = `An error occurred during Write`;
+}
+
+class SocketOpenError extends (/* @__PURE__ */ Error2("effect/socket/Socket/SocketOpenError")({
+  _tag: /* @__PURE__ */ tag("SocketOpenError"),
+  kind: /* @__PURE__ */ Literals(["Unknown", "Timeout"]),
+  cause: /* @__PURE__ */ Defect()
+})) {
+  get message() {
+    return this.kind === "Timeout" ? `timeout waiting for "open"` : `An error occurred during Open`;
+  }
+}
+
+class SocketUpgradeError extends (/* @__PURE__ */ Error2("effect/socket/Socket/SocketUpgradeError")({
+  _tag: /* @__PURE__ */ tag("SocketUpgradeError"),
+  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
+})) {
+  static unsupported = () => fail4(new SocketError({
+    reason: new SocketUpgradeError({})
+  }));
+  get message() {
+    return this.cause === undefined ? `Socket does not support TLS upgrade` : `An error occurred during TLS upgrade`;
+  }
+}
+
+class SocketCloseError extends (/* @__PURE__ */ Error2("effect/socket/Socket/SocketCloseError")({
+  _tag: /* @__PURE__ */ tag("SocketCloseError"),
+  code: Int,
+  closeReason: /* @__PURE__ */ optional(String2)
+})) {
+  get message() {
+    if (this.closeReason) {
+      return `${this.code}: ${this.closeReason}`;
+    }
+    return `${this.code}`;
+  }
+}
+var SocketErrorReason = /* @__PURE__ */ Union([SocketReadError, SocketWriteError, SocketOpenError, SocketUpgradeError, SocketCloseError]);
+
+class SocketError extends (/* @__PURE__ */ TaggedError2(SocketErrorTypeId)("SocketError", {
+  _tag: /* @__PURE__ */ tag("SocketError"),
+  reason: SocketErrorReason
+})) {
+  constructor(props) {
+    if ("cause" in props.reason) {
+      super({
+        ...props,
+        cause: props.reason.cause
+      });
+    } else {
+      super(props);
+    }
+  }
+  [SocketErrorTypeId] = SocketErrorTypeId;
+  static is(u) {
+    return isSocketError(u);
+  }
+  message = this.reason.message;
+}
+var closeError = (code, closeReason) => new SocketError({
+  reason: new SocketCloseError({
+    code,
+    closeReason
+  })
+});
+class WebSocketConstructor extends (/* @__PURE__ */ Service()("@effect/platform/Socket/WebSocketConstructor")) {
+}
+var layerWebSocketConstructorGlobal = /* @__PURE__ */ succeed4(WebSocketConstructor)((url, options) => {
+  if (options !== undefined && typeof options !== "string" && !Array.isArray(options)) {
+    throw new TypeError("WebSocket client options are not supported by the global WebSocket constructor");
+  }
+  return new globalThis.WebSocket(url, options);
+});
+var makeWebSocket = (url, options) => WebSocketConstructor.use((makeWs) => fromWebSocket(acquireRelease((typeof url === "string" ? succeed5(url) : url).pipe(map3((url) => makeWs(url, options?.headers === undefined ? options?.protocols : {
+  protocols: options.protocols,
+  headers: options.headers
+}))), (ws) => sync(() => ws.close(1000))), options));
+var isPausable = (ws) => ("pause" in ws) && typeof ws.pause === "function";
+var fromWebSocket = (acquire, options) => withFiber((fiber) => {
+  let currentWS;
+  const latch = makeUnsafe3(false);
+  const acquireContext = fiber.context;
+  const reader = gen(function* () {
+    const scope2 = yield* scope;
+    const ws = yield* provide(acquire, scope2);
+    if ("binaryType" in ws) {
+      ws.binaryType = "arraybuffer";
+    }
+    const pausable = isPausable(ws);
+    const highWaterMark = options?.highWaterMark ?? (pausable ? defaultHighWaterMark : undefined);
+    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 === undefined)
+        resumeWebSocket();
+      return chunk;
+    }
+    function deliver() {
+      if (waiter === undefined || buffer.length === 0)
+        return;
+      const resume = waiter;
+      waiter = undefined;
+      resume(succeed5(takeBuffer()));
+    }
+    function push(data) {
+      buffer.push(data);
+      if (highWaterMark !== undefined) {
+        bufferSize += typeof data === "string" ? encoder.encode(data).byteLength : data.byteLength;
+      }
+      if (waiter !== undefined)
+        deliver();
+      if (pausable && bufferSize >= highWaterMark) {
+        pauseWebSocket();
+      } else if (!pausable && !waiter && highWaterMark !== undefined && bufferSize > highWaterMark) {
+        fail(new SocketError({
+          reason: new SocketReadError({
+            cause: new Error(`Socket highWaterMark of ${highWaterMark} bytes exceeded`)
+          })
+        }));
+      }
+    }
+    function fail(err) {
+      if (error === undefined)
+        error = err;
+      if (openWaiter !== undefined) {
+        const {
+          cleanup,
+          resume
+        } = openWaiter;
+        openWaiter = undefined;
+        cleanup();
+        resume(fail4(error));
+      }
+      if (waiter !== undefined) {
+        const resume = waiter;
+        waiter = undefined;
+        resume(buffer.length > 0 ? succeed5(takeBuffer()) : fail4(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(new SocketError({
+            reason: new SocketReadError({
+              cause
+            })
+          }));
+        });
+        return;
+      }
+      push(data instanceof ArrayBuffer ? new Uint8Array(data) : data);
+    }
+    function onError(event) {
+      fail(new SocketError({
+        reason: open ? new SocketReadError({
+          cause: event
+        }) : new SocketOpenError({
+          kind: "Unknown",
+          cause: event
+        })
+      }));
+    }
+    function onClose(event) {
+      fail(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(scope2, sync(() => {
+      fail(closeError(1006));
+      ws.removeEventListener("message", onMessage);
+      ws.removeEventListener("error", onError);
+      ws.removeEventListener("close", onClose);
+      if (pausable) {
+        try {
+          resumeWebSocket();
+        } catch {}
+      }
+      latch.closeUnsafe();
+      currentWS = undefined;
+    }));
+    if (ws.readyState >= 2) {
+      return yield* fail4(error ?? closeError(1006));
+    }
+    if (!open) {
+      yield* callback((resume) => {
+        const onOpen = () => {
+          if (openWaiter?.resume !== resume)
+            return;
+          openWaiter = undefined;
+          ws.removeEventListener("open", onOpen);
+          resume(void_2);
+        };
+        const cleanup = () => ws.removeEventListener("open", onOpen);
+        openWaiter = {
+          resume,
+          cleanup
+        };
+        ws.addEventListener("open", onOpen, {
+          once: true
+        });
+        return sync(() => {
+          if (openWaiter?.resume === resume)
+            openWaiter = undefined;
+          cleanup();
+        });
+      }).pipe(timeoutOrElse({
+        duration: options?.openTimeout ?? 1e4,
+        orElse: () => fail4(new SocketError({
+          reason: new SocketOpenError({
+            kind: "Timeout",
+            cause: new Error('timeout waiting for "open"')
+          })
+        }))
+      }));
+      open = true;
+    }
+    if (error === undefined && bufferSize < highWaterMark)
+      resumeWebSocket();
+    currentWS = ws;
+    latch.openUnsafe();
+    return {
+      pull: callback((resume) => {
+        if (buffer.length > 0)
+          return resume(succeed5(takeBuffer()));
+        if (error !== undefined)
+          return resume(fail4(error));
+        waiter = resume;
+        return sync(() => {
+          if (waiter === resume)
+            waiter = undefined;
+        });
+      }),
+      upgrade: SocketUpgradeError.unsupported
+    };
+  }).pipe(updateContext((input) => merge(acquireContext, input)));
+  const write = (chunk) => suspend(() => {
+    const ws = currentWS;
+    if (ws === undefined)
+      return latch.whenOpen(write(chunk));
+    try {
+      if (isCloseEvent(chunk)) {
+        ws.close(chunk.code, chunk.reason);
+      } else {
+        ws.send(chunk);
+      }
+      return void_2;
+    } catch (cause) {
+      return fail4(new SocketError({
+        reason: new SocketWriteError({
+          cause
+        })
+      }));
+    }
+  });
+  const writeAll = (chunks) => suspend(() => {
+    const ws = currentWS;
+    if (ws === undefined)
+      return latch.whenOpen(writeAll(chunks));
+    try {
+      for (let i = 0;i < chunks.length; i++) {
+        ws.send(chunks[i]);
+      }
+      return void_2;
+    } catch (cause) {
+      return fail4(new SocketError({
+        reason: new SocketWriteError({
+          cause
+        })
+      }));
+    }
+  });
+  const writer = succeed5({
+    write,
+    writeAll
+  });
+  return succeed5(make4({
+    reader,
+    writer
+  }));
+});
+var defaultHighWaterMark = 64 * 1024;
+var layerWebSocket = /* @__PURE__ */ flow(makeWebSocket, /* @__PURE__ */ effect(Socket));
+
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/workers/Transferable.js
+class Collector extends (/* @__PURE__ */ Service()("effect/workers/Transferable/Collector")) {
+}
+var 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/.bun/effect@4.0.4/node_modules/effect/dist/workers/WorkerError.js
+class WorkerSpawnError extends (/* @__PURE__ */ Error2("effect/workers/WorkerError/WorkerSpawnError")({
+  _tag: /* @__PURE__ */ tag("WorkerSpawnError"),
+  message: String2,
+  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
+})) {
+}
+
+class WorkerSendError extends (/* @__PURE__ */ Error2("effect/workers/WorkerError/WorkerSendError")({
+  _tag: /* @__PURE__ */ tag("WorkerSendError"),
+  message: String2,
+  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
+})) {
+}
+
+class WorkerReceiveError extends (/* @__PURE__ */ Error2("effect/workers/WorkerError/WorkerReceiveError")({
+  _tag: /* @__PURE__ */ tag("WorkerReceiveError"),
+  message: String2,
+  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
+})) {
+}
+
+class WorkerUnknownError extends (/* @__PURE__ */ Error2("effect/workers/WorkerError/WorkerUnknownError")({
+  _tag: /* @__PURE__ */ tag("WorkerUnknownError"),
+  message: String2,
+  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
+})) {
+}
+var WorkerErrorReason = /* @__PURE__ */ Union([WorkerSpawnError, WorkerSendError, WorkerReceiveError, WorkerUnknownError]);
+
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/internal/tracing.js
+var spanName = (spanPrefix, tag) => spanPrefix === undefined ? tag : `${spanPrefix}.${tag}`;
+var spanAttributes = (tag, attributes) => ({
+  "rpc.system.name": "effect_rpc",
+  "rpc.method": tag,
+  ...attributes
+});
+
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/RpcClientError.js
+var TypeId2 = "~effect/rpc/RpcClientError";
+
+class RpcClientDefect extends (/* @__PURE__ */ Error2("effect/rpc/RpcClientError/RpcClientDefect")({
+  _tag: /* @__PURE__ */ tag("RpcClientDefect"),
+  message: String2,
+  cause: /* @__PURE__ */ Defect()
+})) {
+}
+
+class RpcClientError extends (/* @__PURE__ */ Error2(TypeId2)({
+  _tag: /* @__PURE__ */ tag("RpcClientError"),
+  reason: /* @__PURE__ */ Union([WorkerErrorReason, SocketErrorReason, HttpClientErrorSchema, RpcClientDefect])
+})) {
+  [TypeId2] = TypeId2;
+  get message() {
+    return `${this.reason._tag}: ${this.reason.message}`;
+  }
+}
+
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/RpcMessage.js
+var RequestId = (id) => id;
+var constPing = {
+  _tag: "Ping"
+};
+
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/RpcSerialization.js
+var codecForJson = toCodecJson;
+var sharedTextDecoder;
+var decodeText = (bytes) => (sharedTextDecoder ??= new TextDecoder).decode(bytes);
+
+class RpcSerialization extends (/* @__PURE__ */ Service()("effect/rpc/RpcSerialization")) {
+}
+var defaultMaxBufferSize = 16 * 1024 * 1024;
+var 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)
+  })
+});
+var defaultSchemaBinaryMaxFrameSize = 16 * 1024 * 1024;
+var layerJson = /* @__PURE__ */ succeed4(RpcSerialization)(json);
+
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/Utils.js
+var withRunClient = (f) => suspend(() => {
+  const clientIds = new Set;
+  const clientBuffers = new Map;
+  const clientWrites = 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_2;
+  });
+  return map3(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(() => f(args)), context);
+          }
+        }
+        return yield* onExit(never, () => {
+          clientIds.delete(clientId);
+          clientWrites.delete(clientId);
+          return void_2;
+        });
+      });
+    }
+  }));
+});
+
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/RpcClient.js
+var requestIdCounter = 0;
+var 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 = new Map;
+  let isShutdown = false;
+  yield* addFinalizer(scope, withFiber((parent) => {
+    isShutdown = true;
+    return clearEntries(interrupt(parent.id));
+  }));
+  const clearEntries = fnUntraced(function* (exit) {
+    for (const [id, entry] of entries) {
+      entries.delete(id);
+      if (entry._tag === "Queue") {
+        yield* exit._tag === "Success" ? end(entry.queue) : failCause3(entry.queue, exit.cause);
+      } else {
+        entry.resume(exit);
+      }
+    }
+  });
+  const onRequest = (rpc) => {
+    const isStream = isStreamSchema(rpc.successSchema);
+    const middleware = getRpcClientMiddleware(rpc);
+    return (payload, opts) => {
+      const headers = opts?.headers ? fromInput(opts.headers) : empty3;
+      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(undefined) : 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(map3(queue, fromQueue));
+    };
+  };
+  const onEffectRequest = (rpc, middleware, span, payload, headers, context, discard) => withFiber((parentFiber) => {
+    if (isShutdown) {
+      return interrupt2;
+    }
+    const id = generateRequestId();
+    const send = middleware((message) => options.onFromClient({
+      message,
+      context,
+      discard
+    }), {
+      _tag: "Request",
+      id,
+      tag: rpc._tag,
+      payload,
+      ...span ? {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        sampled: span.sampled
+      } : {},
+      headers: merge3(parentFiber.getRef(CurrentHeaders), headers)
+    });
+    if (discard) {
+      return send;
+    }
+    let fiber;
+    return onInterrupt(callback((resume) => {
+      const entry = {
+        _tag: "Effect",
+        rpc,
+        context,
+        resume(exit) {
+          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") {
+          return resume(exit);
+        }
+      });
+    }), (interruptors) => {
+      entries.delete(id);
+      return andThen(interrupt3(fiber), sendInterrupt(id, Array.from(interruptors), context));
+    });
+  });
+  const onStreamRequest = fnUntraced(function* (rpc, middleware, payload, headers, streamBufferSize, context) {
+    if (isShutdown) {
+      return yield* interrupt2;
+    }
+    const span = disableTracing ? undefined : 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(streamBufferSize);
+    yield* addFinalizerExit(scope, (exit) => {
+      shutdownUnsafe(queue);
+      if (!entries.has(id))
+        return void_2;
+      entries.delete(id);
+      return sendInterrupt(id, isFailure2(exit) ? Array.from(interruptors(exit.cause)) : [], context);
+    });
+    entries.set(id, {
+      _tag: "Queue",
+      rpc,
+      queue,
+      scope,
+      context
+    });
+    yield* middleware((message) => options.onFromClient({
+      message,
+      context,
+      discard: false
+    }), {
+      _tag: "Request",
+      id,
+      tag: rpc._tag,
+      payload,
+      ...span ? {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        sampled: span.sampled
+      } : {},
+      headers: merge3(fiber.getRef(CurrentHeaders), headers)
+    }).pipe(span ? withParentSpan(span, {
+      captureStackTrace: false
+    }) : identity, onError((cause) => failCause3(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();
+    const fiber = options.onFromClient({
+      message: {
+        _tag: "Interrupt",
+        requestId,
+        interruptors
+      },
+      context,
+      discard: false
+    }).pipe(timeout(1000), runForkWith(parentFiber.context));
+    fiber.addObserver(() => {
+      resume(void_2);
+    });
+  });
+  const write = (message) => {
+    switch (message._tag) {
+      case "Chunk": {
+        const requestId = message.requestId;
+        const entry = entries.get(requestId);
+        if (!entry || entry._tag !== "Queue")
+          return void_2;
+        return offerAll(entry.queue, message.values).pipe(supportsAck ? flatMap(() => options.onFromClient({
+          message: {
+            _tag: "Ack",
+            requestId: message.requestId
+          },
+          context: entry.context,
+          discard: false
+        })) : identity, catchCause((cause) => failCause3(entry.queue, cause)));
+      }
+      case "Exit": {
+        const requestId = message.requestId;
+        const entry = entries.get(requestId);
+        if (!entry)
+          return void_2;
+        entries.delete(requestId);
+        if (entry._tag === "Effect") {
+          entry.resume(message.exit);
+          return void_2;
+        }
+        return message.exit._tag === "Success" ? end(entry.queue) : failCause3(entry.queue, message.exit.cause);
+      }
+      case "Defect": {
+        return clearEntries(die2(message.defect));
+      }
+      case "ClientEnd": {
+        return void_2;
+      }
+    }
+  };
+  let client;
+  if (options.flatten) {
+    const fns = 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
+  };
+});
+var clientIdCounter = 0;
+var make5 = /* @__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 = new Map;
+  const interruptRequest = (requestId) => {
+    if (!entries.has(requestId))
+      return void_2;
+    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() : undefined;
+          const fiber = getCurrent();
+          const entry = {
+            rpc,
+            context: collector ? add(fiber.context, Collector, collector) : fiber.context,
+            schemas: rpcSchemas(rpc)
+          };
+          entries.set(message.id, entry);
+          return entry.schemas.encodePayload(message.payload).pipe(provideContext(entry.context), orDie, flatMap((payload) => send(clientId, {
+            ...message,
+            id: message.id,
+            payload,
+            headers: Object.entries(message.headers)
+          }, collector && collector.readUnsafe())));
+        }
+        case "Ack": {
+          const entry = entries.get(message.requestId);
+          if (!entry)
+            return void_2;
+          return send(clientId, {
+            _tag: "Ack",
+            requestId: message.requestId
+          });
+        }
+        case "Interrupt": {
+          return interruptRequest(message.requestId);
+        }
+        case "Eof": {
+          return void_2;
+        }
+      }
+    }
+  });
+  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_2;
+        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(cause)
+        }).pipe(andThen(hasInterrupts(cause) ? void_2 : ignore(interruptRequest(requestId))))), catchCauseIf((cause) => !hasInterrupts(cause), () => void_2)));
+      }
+      case "Exit": {
+        const requestId = RequestId(message.requestId);
+        const entry = entries.get(requestId);
+        if (!entry)
+          return void_2;
+        entries.delete(requestId);
+        return 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(cause)
+          })
+        }));
+      }
+      case "Defect": {
+        return write({
+          _tag: "Defect",
+          clientId: 0,
+          defect: decodeDefect(message.defect)
+        });
+      }
+      case "ClientProtocolError": {
+        const exit = fail2(message.error);
+        return forEach(Array.from(entries.keys()), (requestId) => write({
+          _tag: "Exit",
+          clientId: 0,
+          requestId,
+          exit
+        }));
+      }
+      default: {
+        return void_2;
+      }
+    }
+  }).pipe(catchCause(logError), interruptible, forkScoped);
+  return client;
+});
+var makeRpcSchemas = (codecFor) => {
+  const cache = new WeakMap;
+  return (rpc) => {
+    let entry = cache.get(rpc);
+    if (entry !== undefined) {
+      return entry;
+    }
+    const streamSchemas = getStreamSchemas(rpc.successSchema);
+    entry = {
+      decodeChunk: map(streamSchemas, (streamSchemas) => decodeUnknownEffect(codecFor(NonEmptyArray(streamSchemas.success)))),
+      encodePayload: encodeEffect(codecFor(rpc.payloadSchema)),
+      decodeExit: decodeUnknownEffect(codecFor(exitSchema(rpc)))
+    };
+    cache.set(rpc, entry);
+    return entry;
+  };
+};
+var CurrentHeaders = /* @__PURE__ */ Reference("effect/rpc/RpcClient/CurrentHeaders", {
+  defaultValue: () => empty3
+});
+var withHeaders = /* @__PURE__ */ dual(2, (effect, headers) => updateService(effect, CurrentHeaders, merge3(fromInput(headers))));
+
+class Protocol extends (/* @__PURE__ */ Service()("effect/rpc/RpcClient/Protocol")) {
+  static make = withRunClient;
+}
+var makeProtocolSocket = (options) => Protocol.make(fnUntraced(function* (writeResponse, clientIds) {
+  const socket = yield* Socket;
+  const serialization = yield* RpcSerialization;
+  const hooks = yield* serviceOption(ConnectionHooks);
+  const requestClientMap = new Map;
+  const writer = yield* socket.writer;
+  let parser = serialization.makeUnsafe();
+  const pinger = yield* makePinger(suspend(() => writer.write(parser.encode(constPing))), options);
+  const onPingTimeout = ignoreCause(options?.onPingTimeout ?? void_2, {
+    log: true,
+    message: "RpcClient onPingTimeout hook failed"
+  });
+  let currentError;
+  const broadcast = (response) => forEach(clientIds, (clientId) => writeResponse(clientId, response));
+  const broadcastError = (error) => {
+    currentError = error;
+    return broadcast({
+      _tag: "ClientProtocolError",
+      error
+    });
+  };
+  const processData = (data) => {
+    try {
+      const responses = parser.decode(data);
+      if (responses.length === 0)
+        return void_2;
+      pinger.onFrame();
+      let i = 0;
+      return whileLoop({
+        while: () => i < responses.length,
+        body: () => {
+          const response = responses[i++];
+          if (response._tag === "Pong")
+            return void_2;
+          if (Object.hasOwn(response, "requestId")) {
+            const requestId = response.requestId;
+            const clientId = requestClientMap.get(requestId);
+            if (clientId !== undefined) {
+              if (response._tag === "Exit") {
+                requestClientMap.delete(requestId);
+              }
+              return writeResponse(clientId, response);
+            }
+          }
+          return broadcast(response);
+        },
+        step: constVoid
+      });
+    } catch (defect) {
+      return broadcast({
+        _tag: "ClientProtocolError",
+        error: new RpcClientError({
+          reason: new RpcClientDefect({
+            message: "Error decoding message",
+            cause: defect
+          })
+        })
+      });
+    }
+  };
+  yield* suspend(() => {
+    parser = serialization.makeUnsafe();
+    pinger.reset();
+    let connected = false;
+    return gen(function* () {
+      const {
+        pull
+      } = yield* socket.reader;
+      currentError = undefined;
+      connected = true;
+      if (isSome(hooks)) {
+        yield* hooks.value.onConnect;
+      }
+      while (true) {
+        const frames = yield* pull;
+        for (let i = 0;i < frames.length; i++) {
+          yield* processData(frames[i]);
+        }
+      }
+    }).pipe(scoped, raceFirst(pinger.timeout), andThen(() => connected ? onPingTimeout : void_2), andThen(() => fail4(new SocketError({
+      reason: new SocketReadError({
+        cause: new Error("ping timeout")
+      })
+    }))));
+  }).pipe(isSome(hooks) ? ensuring(hooks.value.onDisconnect) : identity, tapCause((cause) => {
+    const error = findError(cause);
+    const hasError = isSuccess(error);
+    const rpcError = new RpcClientError({
+      reason: hasError ? error.success.reason : new RpcClientDefect({
+        message: "Unknown socket error",
+        cause: squash(cause)
+      })
+    });
+    if (options?.retryTransientErrors && hasError && error.success.reason._tag === "SocketOpenError") {
+      return (options.onTransientError?.(rpcError) ?? void_2).pipe(ignoreCause({
+        log: true,
+        message: "RpcClient onTransientError hook failed"
+      }));
+    }
+    return broadcastError(rpcError);
+  }), retryOrElse(options?.retryPolicy ?? defaultRetryPolicy, (error) => broadcastError(new RpcClientError({
+    reason: error.reason
+  }))), annotateLogs({
+    module: "RpcClient",
+    method: "makeProtocolSocket"
+  }), forkScoped);
+  return {
+    send(clientId, request) {
+      if (currentError) {
+        return fail4(currentError);
+      }
+      if (request._tag === "Request") {
+        requestClientMap.set(request.id, clientId);
+      }
+      const encoded = parser.encode(request);
+      if (encoded === undefined)
+        return void_2;
+      return orDie(writer.write(encoded));
+    },
+    supportsAck: true,
+    supportsTransferables: false,
+    codecFor: serialization.codecFor
+  };
+}));
+var defaultRetryPolicy = /* @__PURE__ */ min([/* @__PURE__ */ exponential(500, 1.5), /* @__PURE__ */ spaced(5000)]);
+var makePinger = /* @__PURE__ */ fnUntraced(function* (writePing, options) {
+  const clock = yield* Clock;
+  const interval = options?.pingInterval ?? "5 seconds";
+  const timeoutMillis = toMillis(options?.pingTimeout ?? interval);
+  let lastSeen = clock.currentTimeMillisUnsafe();
+  const latch = makeUnsafe3();
+  const onFrame = () => {
+    lastSeen = clock.currentTimeMillisUnsafe();
+  };
+  const reset = () => {
+    onFrame();
+    latch.closeUnsafe();
+  };
+  yield* suspend(() => {
+    if (clock.currentTimeMillisUnsafe() - lastSeen > timeoutMillis)
+      return latch.open;
+    return writePing;
+  }).pipe(delay(interval), ignore, forever, interruptible, forkScoped);
+  return {
+    timeout: latch.await,
+    reset,
+    onFrame
+  };
+});
+var layerProtocolSocket = (options) => effect(Protocol)(makeProtocolSocket(options));
+class ConnectionHooks extends (/* @__PURE__ */ Service()("effect/rpc/RpcClient/ConnectionHooks")) {
+}
+
+export { make4, readerString, isCloseEvent, SocketReadError, SocketWriteError, SocketOpenError, SocketUpgradeError, SocketCloseError, SocketError, WebSocketConstructor, layerWebSocketConstructorGlobal, layerWebSocket, layerJson, make5, withHeaders, layerProtocolSocket, ConnectionHooks };