@smthrs/gateway 0.35.0 → 1.0.0-rc.4

package/dist/vendor/chunk-OBWXQKVP.js

@@ -0,0 +1,57 @@
+import {
+  make
+} from "./chunk-6AQLBC2I.js";
+import {
+  layer
+} from "./chunk-UXBGYQR3.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunHttpPlatform.js
+var BunHttpPlatform_exports = {};
+__export(BunHttpPlatform_exports, {
+  layer: () => layer3
+});
+import * as Layer from "effect/Layer";
+import * as Etag from "effect/unstable/http/Etag";
+import * as Platform from "effect/unstable/http/HttpPlatform";
+import * as Response from "effect/unstable/http/HttpServerResponse";
+var compression = /* @__PURE__ */ make(/* @__PURE__ */ Platform.makeCompressionWeb({
+  algorithms: ["gzip", "deflate", "br", "zstd"],
+  transform: (algorithm) => Platform.compressionTransformWeb(algorithm === "br" ? "brotli" : algorithm)
+}));
+var make3 = /* @__PURE__ */ Platform.make({
+  platform: "bun",
+  compression,
+  fileResponse(path, status, statusText, headers, start, end, contentLength) {
+    let file = Bun.file(path);
+    if (start > 0 || end !== void 0) {
+      file = file.slice(start, end);
+    }
+    return Response.raw(file, {
+      headers: {
+        ...headers,
+        "content-length": contentLength.toString()
+      },
+      status,
+      statusText
+    });
+  },
+  fileWebResponse(file, status, statusText, headers, options) {
+    const start = options?.offset ?? 0;
+    const end = options?.bytesToRead !== void 0 ? start + options.bytesToRead : void 0;
+    const body = start > 0 || end !== void 0 ? file.slice(start, end, file.type) : file;
+    return Response.raw(body, {
+      headers,
+      status,
+      statusText
+    });
+  }
+});
+var layer3 = /* @__PURE__ */ Layer.effect(Platform.HttpPlatform)(make3).pipe(/* @__PURE__ */ Layer.provide(layer), /* @__PURE__ */ Layer.provide(Etag.layer));
+
+export {
+  layer3 as layer,
+  BunHttpPlatform_exports
+};

package/dist/vendor/chunk-QR557K66.js

@@ -0,0 +1,20 @@
+import {
+  fromWritable,
+  fromWritableChannel,
+  pullIntoWritable
+} from "./chunk-37CUR3PO.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunSink.js
+var BunSink_exports = {};
+__export(BunSink_exports, {
+  fromWritable: () => fromWritable,
+  fromWritableChannel: () => fromWritableChannel,
+  pullIntoWritable: () => pullIntoWritable
+});
+
+export {
+  BunSink_exports
+};

package/dist/vendor/chunk-R4QUY7DH.js

@@ -0,0 +1,18 @@
+import {
+  runMain
+} from "./chunk-TFY7W6D4.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/NodeRuntime.js
+var NodeRuntime_exports = {};
+__export(NodeRuntime_exports, {
+  runMain: () => runMain2
+});
+var runMain2 = runMain;
+
+export {
+  runMain2 as runMain,
+  NodeRuntime_exports
+};

package/dist/vendor/chunk-RGECXXJS.js

@@ -0,0 +1,18 @@
+import {
+  runMain
+} from "./chunk-TFY7W6D4.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunRuntime.js
+var BunRuntime_exports = {};
+__export(BunRuntime_exports, {
+  runMain: () => runMain2
+});
+var runMain2 = runMain;
+
+export {
+  runMain2 as runMain,
+  BunRuntime_exports
+};

package/dist/vendor/chunk-TFY7W6D4.js

@@ -0,0 +1,36 @@
+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/NodeRuntime.js
+var NodeRuntime_exports = {};
+__export(NodeRuntime_exports, {
+  runMain: () => runMain
+});
+import * as Runtime from "effect/Runtime";
+var runMain = /* @__PURE__ */ Runtime.makeRunMain(({
+  fiber,
+  teardown
+}) => {
+  let receivedSignal = false;
+  fiber.addObserver((exit) => {
+    process.removeListener("SIGINT", onSigint);
+    process.removeListener("SIGTERM", onSigint);
+    teardown(exit, (code) => {
+      if (receivedSignal || code !== 0) {
+        process.exit(code);
+      }
+    });
+  });
+  function onSigint() {
+    receivedSignal = true;
+    fiber.interruptUnsafe(fiber.id);
+  }
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigint);
+});
+
+export {
+  runMain,
+  NodeRuntime_exports
+};

package/dist/vendor/chunk-TGPIVY4A.js

@@ -0,0 +1,104 @@
+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/NodeWorkerRunner.js
+var NodeWorkerRunner_exports = {};
+__export(NodeWorkerRunner_exports, {
+  layer: () => layer
+});
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/unstable/workers/WorkerError";
+import * as WorkerRunner from "effect/unstable/workers/WorkerRunner";
+import * as WorkerThreads from "node:worker_threads";
+var layer = /* @__PURE__ */ Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
+  start() {
+    return Effect.gen(function* () {
+      if (!WorkerThreads.parentPort && !process.send) {
+        return yield* new WorkerError({
+          reason: new WorkerSpawnError({
+            message: "not in a worker"
+          })
+        });
+      }
+      const sendRaw = WorkerThreads.parentPort ? (_portId, message, transfers) => WorkerThreads.parentPort.postMessage(message, transfers) : (_portId, message, _transfers) => process.send(message);
+      const sendUnsafe = (_portId, message, transfers) => sendRaw(_portId, [1, message], transfers);
+      const send = (_portId, message, transfers) => Effect.sync(() => sendUnsafe(_portId, message, transfers));
+      const run = (handler) => Effect.scopedWith(Effect.fnUntraced(function* (scope) {
+        const closeLatch = Deferred.makeUnsafe();
+        const trackFiber = Fiber.runIn(scope);
+        const services = yield* Effect.context();
+        const runFork = Effect.runForkWith(services);
+        const onExit = (exit) => {
+          if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
+            runFork(Effect.logError("unhandled error in worker", exit.cause));
+          }
+        };
+        const port = WorkerThreads.parentPort ?? process;
+        function onMessage(message) {
+          if (message[0] === 0) {
+            const result = handler(0, message[1]);
+            if (Effect.isEffect(result)) {
+              const fiber = runFork(result);
+              fiber.addObserver(onExit);
+              trackFiber(fiber);
+            }
+          } else {
+            if (WorkerThreads.parentPort) {
+              WorkerThreads.parentPort.close();
+            } else {
+              process.channel?.unref();
+            }
+            Deferred.doneUnsafe(closeLatch, Exit.void);
+          }
+        }
+        port.on("message", onMessage);
+        function onMessageError(cause) {
+          Deferred.doneUnsafe(closeLatch, new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "received messageerror event",
+              cause
+            })
+          }));
+        }
+        function onError(cause) {
+          Deferred.doneUnsafe(closeLatch, new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "received error event",
+              cause
+            })
+          }));
+        }
+        if (WorkerThreads.parentPort) {
+          WorkerThreads.parentPort.on("messageerror", onMessageError);
+          WorkerThreads.parentPort.on("error", onError);
+        }
+        yield* Scope.addFinalizer(scope, Effect.sync(() => {
+          port.off("message", onMessage);
+          if (WorkerThreads.parentPort) {
+            WorkerThreads.parentPort.off("messageerror", onMessageError);
+            WorkerThreads.parentPort.off("error", onError);
+          }
+        }));
+        sendRaw(0, [0]);
+        return yield* Deferred.await(closeLatch);
+      }));
+      return {
+        run,
+        send,
+        sendUnsafe
+      };
+    });
+  }
+});
+
+export {
+  layer,
+  NodeWorkerRunner_exports
+};

package/dist/vendor/chunk-TGXCX6W3.js

@@ -0,0 +1,398 @@
+import {
+  persisted,
+  stream
+} from "./chunk-ML2NAFH2.js";
+import {
+  layer as layer2
+} from "./chunk-ZPIG2CUA.js";
+import {
+  NodeHttpIncomingMessage
+} from "./chunk-W4OASVX6.js";
+import {
+  layer
+} from "./chunk-AVVVN75Z.js";
+import {
+  NodeWS
+} from "./chunk-YDASSC75.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
+};