@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/vendor/chunk-RO2R4MJH.js

@@ -0,0 +1,62 @@
+import {
+  layer as layer2
+} from "./chunk-SIR62W3Y.js";
+import {
+  layerWebSocketConstructor
+} from "./chunk-5ZMHBXIK.js";
+import {
+  layerK8sHttpClient
+} from "./chunk-FNZOJHSV.js";
+import {
+  layer
+} from "./chunk-VZBDV3TV.js";
+import {
+  layerUndici
+} from "./chunk-KOZMM5PZ.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeClusterHttp.js
+var NodeClusterHttp_exports = {};
+__export(NodeClusterHttp_exports, {
+  layer: () => layer5,
+  layerHttpServer: () => layerHttpServer,
+  layerK8sHttpClient: () => layerK8sHttpClient
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as HttpRunner from "effect/unstable/cluster/HttpRunner";
+import * as MessageStorage from "effect/unstable/cluster/MessageStorage";
+import * as RunnerHealth from "effect/unstable/cluster/RunnerHealth";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as RunnerStorage from "effect/unstable/cluster/RunnerStorage";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import * as SqlMessageStorage from "effect/unstable/cluster/SqlMessageStorage";
+import * as SqlRunnerStorage from "effect/unstable/cluster/SqlRunnerStorage";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import { createServer } from "node:http";
+var layer5 = (options) => {
+  const layer6 = options.clientOnly ? options.transport === "http" ? Layer.provide(HttpRunner.layerHttpClientOnly, layerUndici) : Layer.provide(HttpRunner.layerWebsocketClientOnly, layerWebSocketConstructor) : options.transport === "http" ? Layer.provide(HttpRunner.layerHttp, [layerHttpServer, layerUndici]) : Layer.provide(HttpRunner.layerWebsocket, [layerHttpServer, layerWebSocketConstructor]);
+  const runnerHealth = options?.clientOnly ? Layer.empty : options?.runnerHealth === "k8s" ? RunnerHealth.layerK8s(options.runnerHealthK8s).pipe(Layer.provide(layerK8sHttpClient)) : RunnerHealth.layerPing.pipe(Layer.provide(Runners.layerRpc), Layer.provide(options.transport === "http" ? HttpRunner.layerClientProtocolHttpDefault.pipe(Layer.provide(layerUndici)) : HttpRunner.layerClientProtocolWebsocketDefault.pipe(Layer.provide(layerWebSocketConstructor))));
+  return layer6.pipe(Layer.provide(runnerHealth), Layer.provideMerge(options?.storage === "local" ? MessageStorage.layerNoop : options?.storage === "byo" ? Layer.empty : Layer.orDie(SqlMessageStorage.layer).pipe(Layer.provide(layer))), Layer.provide(options?.storage === "local" ? RunnerStorage.layerMemory : options?.storage === "byo" ? Layer.empty : Layer.orDie(SqlRunnerStorage.layer)), Layer.provide(ShardingConfig.layerFromEnv(options?.shardingConfig)), Layer.provide(options?.serialization === "ndjson" ? RpcSerialization.layerNdjsonWith({
+    maxBufferSize: options.serializationMaxBufferSize
+  }) : RpcSerialization.layerSchemaBinary({
+    maxFrameSize: options.serializationMaxBufferSize
+  })));
+};
+var layerHttpServer = /* @__PURE__ */ Effect.gen(function* () {
+  const config = yield* ShardingConfig.ShardingConfig;
+  const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress);
+  if (Option.isNone(listenAddress)) {
+    return yield* Effect.die("NodeClusterHttp.layerHttpServer: ShardingConfig.runnerAddress is None");
+  }
+  return layer2(createServer, listenAddress.value);
+}).pipe(Layer.unwrap);
+
+export {
+  layer5 as layer,
+  layerHttpServer,
+  NodeClusterHttp_exports
+};

package/dist/vendor/chunk-SIR62W3Y.js

@@ -0,0 +1,398 @@
+import {
+  persisted,
+  stream
+} from "./chunk-GXCHI7BM.js";
+import {
+  layer as layer2
+} from "./chunk-AMQKOQNT.js";
+import {
+  NodeWS
+} from "./chunk-JJ24ARBQ.js";
+import {
+  NodeHttpIncomingMessage
+} from "./chunk-J7A4CZDO.js";
+import {
+  layer
+} from "./chunk-VANKHF46.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeHttpServer.js
+var NodeHttpServer_exports = {};
+__export(NodeHttpServer_exports, {
+  layer: () => layer4,
+  layerConfig: () => layerConfig,
+  layerHttpServices: () => layerHttpServices,
+  layerServer: () => layerServer,
+  layerTest: () => layerTest,
+  make: () => make2,
+  makeHandler: () => makeHandler,
+  makeUpgradeHandler: () => makeUpgradeHandler
+});
+import * as Cause from "effect/Cause";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import { flow } from "effect/Function";
+import * as Latch from "effect/Latch";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import * as Cookies from "effect/unstable/http/Cookies";
+import * as Etag from "effect/unstable/http/Etag";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as HttpEffect from "effect/unstable/http/HttpEffect";
+import * as HttpIncomingMessage from "effect/unstable/http/HttpIncomingMessage";
+import * as HttpServer from "effect/unstable/http/HttpServer";
+import { causeResponse, ClientAbort, HttpServerError, RequestParseError, ResponseError, ServeError } from "effect/unstable/http/HttpServerError";
+import * as Request from "effect/unstable/http/HttpServerRequest";
+import { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+import * as NetAddress from "effect/unstable/net/NetAddress";
+import * as Socket from "effect/unstable/socket/Socket";
+import * as Http from "node:http";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var make2 = /* @__PURE__ */ Effect.fnUntraced(function* (evaluate, options) {
+  const scope2 = yield* Effect.scope;
+  const server = evaluate();
+  const shutdown = yield* Effect.callback((resume) => {
+    if (!server.listening) {
+      return resume(Effect.void);
+    }
+    server.close((error) => {
+      if (error) {
+        resume(Effect.die(error));
+      } else {
+        resume(Effect.void);
+      }
+    });
+  }).pipe(Effect.cached);
+  const preemptiveShutdown = options.disablePreemptiveShutdown ? Effect.void : Effect.timeoutOrElse(shutdown, {
+    duration: options.gracefulShutdownTimeout ?? Duration.seconds(20),
+    orElse: () => Effect.void
+  });
+  yield* Scope.addFinalizer(scope2, shutdown);
+  yield* Effect.callback((resume) => {
+    function onError(cause) {
+      resume(Effect.fail(new ServeError({
+        cause
+      })));
+    }
+    server.on("error", onError);
+    server.listen(options, () => {
+      server.off("error", onError);
+      resume(Effect.void);
+    });
+  });
+  const address = server.address();
+  const effectAddress = typeof address === "string" ? Effect.succeed(NetAddress.unixPathAddress(address)) : Effect.fromResult(NetAddress.inetAddressFromIpString(address.address, address.port)).pipe(Effect.mapError((cause) => new ServeError({
+    cause
+  })));
+  const boundAddress = yield* effectAddress;
+  const wss = yield* Effect.acquireRelease(Effect.sync(() => new NodeWS.WebSocketServer({
+    ...options.websocket,
+    noServer: true
+  })), (wss2) => Effect.callback((resume) => {
+    wss2.close(() => resume(Effect.void));
+  })).pipe(Scope.provide(scope2), Effect.cached);
+  return HttpServer.make({
+    address: boundAddress,
+    serve: Effect.fnUntraced(function* (httpApp, middleware) {
+      const serveScope = yield* Effect.scope;
+      const scope3 = Scope.forkUnsafe(serveScope, "parallel");
+      const handler = yield* makeHandler(httpApp, {
+        middleware,
+        scope: scope3
+      });
+      const upgradeHandler = yield* makeUpgradeHandler(wss, httpApp, {
+        middleware,
+        scope: scope3
+      });
+      yield* Scope.addFinalizerExit(serveScope, () => {
+        server.off("request", handler);
+        server.off("upgrade", upgradeHandler);
+        return preemptiveShutdown;
+      });
+      server.on("request", handler);
+      server.on("upgrade", upgradeHandler);
+    })
+  });
+});
+var makeHandler = (httpEffect, options) => {
+  const handled = HttpEffect.toHandled(httpEffect, handleResponse, options.middleware);
+  return Effect.withFiber((parent) => {
+    const services = parent.context;
+    return Effect.succeed(function handler(nodeRequest, nodeResponse) {
+      const context = Context.add(services, HttpServerRequest, new ServerRequestImpl(nodeRequest, nodeResponse));
+      const fiber = Fiber.runIn(Effect.runForkWith(context)(handled), options.scope);
+      if (fiber.pollUnsafe() === void 0) {
+        nodeResponse.on("close", () => {
+          if (!nodeResponse.writableEnded) {
+            fiber.interruptUnsafe(parent.id, ClientAbort.annotation);
+          }
+        });
+      }
+    });
+  });
+};
+var makeUpgradeHandler = (lazyWss, httpEffect, options) => {
+  const handledApp = HttpEffect.toHandled(httpEffect, handleResponse, options.middleware);
+  return Effect.withFiber((parent) => {
+    const services = parent.context;
+    return Effect.succeed(function handler(nodeRequest, socket, head) {
+      let upgraded = false;
+      let nodeResponse_ = void 0;
+      const nodeResponse = () => {
+        if (nodeResponse_ === void 0) {
+          nodeResponse_ = new Http.ServerResponse(nodeRequest);
+          if (upgraded) {
+            nodeResponse_.end();
+          } else {
+            nodeResponse_.assignSocket(socket);
+            nodeResponse_.on("finish", () => {
+              socket.end();
+            });
+          }
+        }
+        return nodeResponse_;
+      };
+      const upgradeEffect = Socket.fromWebSocket(Effect.flatMap(lazyWss, (wss) => Effect.acquireRelease(Effect.callback((resume) => wss.handleUpgrade(nodeRequest, socket, head, (ws) => {
+        upgraded = true;
+        resume(Effect.succeed(ws));
+      })), (ws) => Effect.sync(() => ws.close()))));
+      const context = Context.add(services, HttpServerRequest, new ServerRequestImpl(nodeRequest, nodeResponse, upgradeEffect));
+      const fiber = Fiber.runIn(Effect.runForkWith(context)(handledApp), options.scope);
+      socket.on("error", () => {
+      });
+      socket.on("close", () => {
+        if (!socket.writableEnded) {
+          fiber.interruptUnsafe(parent.id, ClientAbort.annotation);
+        }
+      });
+    });
+  });
+};
+var ServerRequestImpl = class _ServerRequestImpl extends NodeHttpIncomingMessage {
+  [Request.TypeId];
+  response;
+  upgradeEffect;
+  url;
+  headersOverride;
+  constructor(source, response, upgradeEffect, url = source.url, headersOverride, remoteAddressOverride) {
+    super(source, (cause) => new HttpServerError({
+      reason: new RequestParseError({
+        request: this,
+        cause
+      })
+    }), remoteAddressOverride);
+    this[Request.TypeId] = Request.TypeId;
+    this.response = response;
+    this.upgradeEffect = upgradeEffect;
+    this.url = url;
+    this.headersOverride = headersOverride;
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies;
+    }
+    return this.cachedCookies = Cookies.parseHeader(this.headers.cookie ?? "");
+  }
+  get resolvedResponse() {
+    return typeof this.response === "function" ? this.response() : this.response;
+  }
+  modify(options) {
+    return new _ServerRequestImpl(this.source, this.response, this.upgradeEffect, options.url ?? this.url, options.headers ?? this.headersOverride, "remoteAddress" in options ? options.remoteAddress : this.remoteAddressOverride);
+  }
+  get originalUrl() {
+    return this.source.url;
+  }
+  cachedMethod;
+  get method() {
+    return this.cachedMethod ??= this.source.method.toUpperCase();
+  }
+  get headers() {
+    this.headersOverride ??= this.source.headers;
+    return this.headersOverride;
+  }
+  multipartEffect;
+  get multipart() {
+    if (this.multipartEffect) {
+      return this.multipartEffect;
+    }
+    this.multipartEffect = Effect.runSync(Effect.cached(persisted(this.source, this.source.headers)));
+    return this.multipartEffect;
+  }
+  get multipartStream() {
+    return stream(this.source, this.source.headers);
+  }
+  get upgrade() {
+    return this.upgradeEffect ?? Effect.fail(new HttpServerError({
+      reason: new RequestParseError({
+        request: this,
+        description: "not an upgradeable ServerRequest"
+      })
+    }));
+  }
+  toString() {
+    return `ServerRequest(${this.method} ${this.url})`;
+  }
+  toJSON() {
+    return HttpIncomingMessage.inspect(this, {
+      _id: "HttpServerRequest",
+      method: this.method,
+      url: this.originalUrl
+    });
+  }
+};
+var layerServer = /* @__PURE__ */ flow(make2, /* @__PURE__ */ Layer.effect(HttpServer.HttpServer));
+var layerHttpServices = /* @__PURE__ */ Layer.mergeAll(layer, Etag.layerWeak, layer2);
+var layer4 = (evaluate, options) => Layer.mergeAll(layerServer(evaluate, options), layerHttpServices);
+var layerConfig = (evaluate, options) => Layer.mergeAll(Layer.effect(HttpServer.HttpServer)(Effect.flatMap(Config.unwrap(options), (options2) => make2(evaluate, options2))), layerHttpServices);
+var layerTest = /* @__PURE__ */ HttpServer.layerTestClient.pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ Layer.fresh(FetchHttpClient.layer).pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ Layer.succeed(FetchHttpClient.RequestInit)({
+  keepalive: false
+})))), /* @__PURE__ */ Layer.provideMerge(/* @__PURE__ */ layer4(Http.createServer, {
+  port: 0
+})));
+var handleResponse = (request, response) => {
+  const nodeResponse = request.resolvedResponse;
+  if (nodeResponse.writableEnded) {
+    return Effect.void;
+  }
+  let headers = response.headers;
+  if (!Cookies.isEmpty(response.cookies)) {
+    headers = {
+      ...headers
+    };
+    const toSet = Cookies.toSetCookieHeaders(response.cookies);
+    if (headers["set-cookie"] !== void 0) {
+      toSet.push(headers["set-cookie"]);
+    }
+    headers["set-cookie"] = toSet;
+  }
+  if (request.method === "HEAD") {
+    nodeResponse.writeHead(response.status, response.statusText, headers);
+    return Effect.andThen(cancelResponseBody(response.body), Effect.callback((resume) => {
+      let completed = false;
+      const done = () => {
+        if (completed) return;
+        completed = true;
+        nodeResponse.off("close", done);
+        resume(Effect.void);
+      };
+      nodeResponse.once("close", done);
+      nodeResponse.end(done);
+    }));
+  }
+  const body = response.body;
+  switch (body._tag) {
+    case "Empty": {
+      nodeResponse.writeHead(response.status, response.statusText, headers);
+      nodeResponse.end();
+      return Effect.void;
+    }
+    case "Raw": {
+      nodeResponse.writeHead(response.status, response.statusText, headers);
+      if (typeof body.body === "object" && body.body !== null && "pipe" in body.body && typeof body.body.pipe === "function") {
+        return Effect.tryPromise({
+          try: (signal) => pipeline(body.body, nodeResponse, {
+            signal,
+            end: true
+          }),
+          catch: (cause) => new HttpServerError({
+            reason: new ResponseError({
+              request,
+              response,
+              description: "Error writing raw response",
+              cause
+            })
+          })
+        }).pipe(Effect.interruptible, Effect.tapCause(handleCause(nodeResponse, response)));
+      }
+      return Effect.callback((resume) => {
+        nodeResponse.end(body.body, () => resume(Effect.void));
+      });
+    }
+    case "Uint8Array": {
+      nodeResponse.writeHead(response.status, response.statusText, headers);
+      if (body.contentLength < 1024 * 1024) {
+        nodeResponse.end(body.text ?? body.body);
+        return Effect.void;
+      }
+      return Effect.callback((resume) => {
+        nodeResponse.end(body.text ?? body.body, () => resume(Effect.void));
+      });
+    }
+    case "FormData": {
+      return Effect.suspend(() => {
+        const r = new globalThis.Response(body.formData);
+        nodeResponse.writeHead(response.status, response.statusText, {
+          ...headers,
+          ...Object.fromEntries(r.headers)
+        });
+        return Effect.callback((resume, signal) => {
+          Readable.fromWeb(r.body, {
+            signal
+          }).pipe(nodeResponse).on("error", (cause) => {
+            resume(Effect.fail(new HttpServerError({
+              reason: new ResponseError({
+                request,
+                response,
+                description: "Error writing FormData response",
+                cause
+              })
+            })));
+          }).once("finish", () => {
+            resume(Effect.void);
+          });
+        }).pipe(Effect.interruptible, Effect.tapCause(handleCause(nodeResponse, response)));
+      });
+    }
+    case "Stream": {
+      nodeResponse.writeHead(response.status, response.statusText, headers);
+      const drainLatch = Latch.makeUnsafe();
+      nodeResponse.on("drain", () => drainLatch.openUnsafe());
+      return body.stream.pipe(Stream.orDie, Stream.runForEachArray((array) => {
+        const chunk = array.length > 1 ? Buffer.concat(array) : array[0];
+        if (nodeResponse.write(chunk)) return Effect.void;
+        drainLatch.closeUnsafe();
+        return drainLatch.await;
+      }), Effect.interruptible, Effect.matchCauseEffect({
+        onSuccess: () => Effect.sync(() => nodeResponse.end()),
+        onFailure: handleCause(nodeResponse, response)
+      }));
+    }
+  }
+};
+var cancelResponseBody = (body) => {
+  const stream2 = body._tag === "Raw" ? body.body : void 0;
+  if (stream2 instanceof Readable) {
+    return Effect.sync(() => stream2.destroy());
+  }
+  return Effect.void;
+};
+var handleCause = (nodeResponse, originalResponse) => (originalCause) => Effect.flatMap(causeResponse(originalCause), ([response, cause]) => {
+  const headersSent = nodeResponse.headersSent;
+  if (!headersSent) {
+    nodeResponse.writeHead(response.status, response.statusText);
+  }
+  if (!nodeResponse.writableEnded) {
+    nodeResponse.end();
+  }
+  return Effect.failCause(headersSent ? Cause.combine(originalCause, Cause.die(originalResponse)) : cause);
+});
+
+export {
+  make2 as make,
+  makeHandler,
+  makeUpgradeHandler,
+  layerServer,
+  layerHttpServices,
+  layer4 as layer,
+  layerConfig,
+  layerTest,
+  NodeHttpServer_exports
+};

package/dist/vendor/chunk-TFIKFFSC.js

@@ -0,0 +1,26 @@
+import {
+  layer,
+  layerPosix,
+  layerWin32
+} from "./chunk-54RLBMTZ.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodePath.js
+var NodePath_exports = {};
+__export(NodePath_exports, {
+  layer: () => layer2,
+  layerPosix: () => layerPosix2,
+  layerWin32: () => layerWin322
+});
+var layer2 = layer;
+var layerPosix2 = layerPosix;
+var layerWin322 = layerWin32;
+
+export {
+  layer2 as layer,
+  layerPosix2 as layerPosix,
+  layerWin322 as layerWin32,
+  NodePath_exports
+};

package/dist/vendor/chunk-TXKLEBBL.js

@@ -0,0 +1,143 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeTerminal.js
+var NodeTerminal_exports = {};
+__export(NodeTerminal_exports, {
+  layer: () => layer,
+  make: () => make4
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { badArgument } from "effect/PlatformError";
+import * as Predicate from "effect/Predicate";
+import * as Queue from "effect/Queue";
+import * as RcRef from "effect/RcRef";
+import * as Terminal from "effect/Terminal";
+import * as readline from "node:readline";
+var make4 = /* @__PURE__ */ Effect.fnUntraced(function* (shouldQuit = defaultShouldQuit) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const lines = yield* Queue.make();
+  let inputEnded = stdin.readableEnded;
+  let readlineActive = false;
+  const onStdinEnd = () => {
+    inputEnded = true;
+    if (!readlineActive) {
+      Queue.endUnsafe(lines);
+    }
+  };
+  stdin.once("end", onStdinEnd);
+  yield* Effect.addFinalizer(() => Effect.sync(() => stdin.off("end", onStdinEnd)));
+  const rlRef = yield* RcRef.make({
+    acquire: Effect.acquireRelease(Effect.sync(() => {
+      const rl = readline.createInterface({
+        input: stdin,
+        escapeCodeTimeout: 50
+      });
+      const onLine = (line) => Queue.offerUnsafe(lines, line);
+      const onClose = () => {
+        readlineActive = false;
+        Queue.endUnsafe(lines);
+      };
+      readlineActive = true;
+      readline.emitKeypressEvents(stdin, rl);
+      rl.on("line", onLine);
+      rl.once("close", onClose);
+      if (stdin.isTTY) {
+        stdin.setRawMode(true);
+      }
+      return {
+        rl,
+        onClose,
+        onLine
+      };
+    }), ({
+      rl,
+      onClose,
+      onLine
+    }) => Effect.sync(() => {
+      readlineActive = false;
+      rl.off("line", onLine);
+      rl.off("close", onClose);
+      if (stdin.isTTY) {
+        stdin.setRawMode(false);
+      }
+      rl.close();
+      if (inputEnded) {
+        Queue.endUnsafe(lines);
+      }
+    })),
+    idleTimeToLive: "10 millis"
+  });
+  const columns = Effect.sync(() => stdout.columns ?? 0);
+  const rows = Effect.sync(() => stdout.rows ?? 0);
+  const readInput = Effect.gen(function* () {
+    const queue = yield* Queue.make();
+    const handleKeypress = (s, k) => {
+      const userInput = {
+        input: Option.fromUndefinedOr(s),
+        key: {
+          name: k.name ?? "",
+          ctrl: !!k.ctrl,
+          meta: !!k.meta,
+          shift: !!k.shift
+        }
+      };
+      Queue.offerUnsafe(queue, userInput);
+      if (shouldQuit(userInput)) {
+        Queue.endUnsafe(queue);
+      }
+    };
+    const keepAlive = setInterval(() => {
+    }, 2147483647);
+    const handleEnd = () => {
+      clearInterval(keepAlive);
+      Queue.endUnsafe(queue);
+    };
+    yield* Effect.addFinalizer(() => Effect.sync(() => {
+      clearInterval(keepAlive);
+      stdin.off("keypress", handleKeypress);
+      stdin.off("end", handleEnd);
+    }));
+    stdin.on("keypress", handleKeypress);
+    if (inputEnded) {
+      handleEnd();
+    } else {
+      yield* RcRef.get(rlRef);
+      stdin.once("end", handleEnd);
+    }
+    return queue;
+  });
+  const readLine = Effect.suspend(() => Queue.poll(lines).pipe(Effect.flatMap(Option.match({
+    onNone: () => Effect.scoped(Effect.andThen(RcRef.get(rlRef), Queue.take(lines))),
+    onSome: Effect.succeed
+  })), Effect.mapError(() => new Terminal.QuitError({}))));
+  const display = (prompt) => Effect.uninterruptible(Effect.callback((resume) => {
+    stdout.write(prompt, (err) => Predicate.isNullish(err) ? resume(Effect.void) : resume(Effect.fail(badArgument({
+      module: "Terminal",
+      method: "display",
+      description: "Failed to write prompt to stdout",
+      cause: err
+    }))));
+  }));
+  return Terminal.make({
+    columns,
+    rows,
+    readInput,
+    readLine,
+    display
+  });
+});
+var layer = /* @__PURE__ */ Layer.effect(Terminal.Terminal, /* @__PURE__ */ make4(defaultShouldQuit));
+function defaultShouldQuit(input) {
+  return input.key.ctrl && (input.key.name === "c" || input.key.name === "d");
+}
+
+export {
+  make4 as make,
+  layer,
+  NodeTerminal_exports
+};

package/dist/vendor/chunk-UFH5UUZK.js

@@ -0,0 +1,48 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeCrypto.js
+var NodeCrypto_exports = {};
+__export(NodeCrypto_exports, {
+  layer: () => layer,
+  make: () => make2
+});
+import * as EffectCrypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as PlatformError from "effect/PlatformError";
+import * as NodeCrypto from "node:crypto";
+var toHashAlgorithm = (algorithm) => {
+  switch (algorithm) {
+    case "SHA-1":
+      return "sha1";
+    case "SHA-256":
+      return "sha256";
+    case "SHA-384":
+      return "sha384";
+    case "SHA-512":
+      return "sha512";
+  }
+};
+var digest = (algorithm, data) => Effect.try({
+  try: () => Uint8Array.from(NodeCrypto.createHash(toHashAlgorithm(algorithm)).update(data).digest()),
+  catch: (cause) => PlatformError.systemError({
+    module: "Crypto",
+    method: "digest",
+    _tag: "Unknown",
+    description: "Could not compute digest",
+    cause
+  })
+});
+var make2 = /* @__PURE__ */ EffectCrypto.make({
+  randomBytes: NodeCrypto.randomBytes,
+  digest
+});
+var layer = /* @__PURE__ */ Layer.succeed(EffectCrypto.Crypto, make2);
+
+export {
+  make2 as make,
+  layer,
+  NodeCrypto_exports
+};