@smthrs/platform-bun 0.0.0-stage → 1.0.0-rc.3

package/dist/vendor/chunk-KWOY4JDR.js

@@ -0,0 +1,398 @@
+import {
+  persisted,
+  stream
+} from "./chunk-GXCHI7BM.js";
+import {
+  layer as layer2
+} from "./chunk-64Q2B7BA.js";
+import {
+  NodeHttpIncomingMessage
+} from "./chunk-J7A4CZDO.js";
+import {
+  layer
+} from "./chunk-MMEGG3WE.js";
+import {
+  NodeWS
+} from "./chunk-JJ24ARBQ.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-LEUPYT3Q.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-LJVI2DIF.js

@@ -0,0 +1,57 @@
+import {
+  make
+} from "./chunk-3GR5VZ2M.js";
+import {
+  layer
+} from "./chunk-MSWDMTAF.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-M32LDTW7.js

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-BKTBUBQY.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/NodeFileSystem.js
+var NodeFileSystem_exports = {};
+__export(NodeFileSystem_exports, {
+  layer: () => layer2
+});
+var layer2 = layer;
+
+export {
+  layer2 as layer,
+  NodeFileSystem_exports
+};

package/dist/vendor/chunk-MBSKBQ5D.js

@@ -0,0 +1,21 @@
+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/NodeHttpServerRequest.js
+var NodeHttpServerRequest_exports = {};
+__export(NodeHttpServerRequest_exports, {
+  toIncomingMessage: () => toIncomingMessage,
+  toServerResponse: () => toServerResponse
+});
+var toIncomingMessage = (self) => self.source;
+var toServerResponse = (self) => {
+  const res = self.response;
+  return typeof res === "function" ? res() : res;
+};
+
+export {
+  toIncomingMessage,
+  toServerResponse,
+  NodeHttpServerRequest_exports
+};

package/dist/vendor/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/vendor/chunk-MMEGG3WE.js

@@ -0,0 +1,96 @@
+import {
+  layer
+} from "./chunk-M32LDTW7.js";
+import {
+  pipeThroughDuplex
+} from "./chunk-XH4U3JSV.js";
+import {
+  algorithms,
+  compressTransform,
+  make
+} from "./chunk-3GR5VZ2M.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/NodeHttpPlatform.js
+var NodeHttpPlatform_exports = {};
+__export(NodeHttpPlatform_exports, {
+  layer: () => layer3,
+  make: () => make3
+});
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as EtagImpl from "effect/unstable/http/Etag";
+import * as Headers from "effect/unstable/http/Headers";
+import * as HttpBody from "effect/unstable/http/HttpBody";
+import * as Platform from "effect/unstable/http/HttpPlatform";
+import * as ServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as Mime from "effect/unstable/http/Mime";
+import * as Fs from "node:fs";
+import { Readable } from "node:stream";
+var compressedBody = (response, body) => ServerResponse.removeHeader(ServerResponse.setBody(response, body), "content-length");
+var compression = /* @__PURE__ */ make({
+  algorithms,
+  compressResponse(response, algorithm, options) {
+    const body = response.body;
+    switch (body._tag) {
+      case "Stream": {
+        return Effect.succeed(compressedBody(response, HttpBody.stream(pipeThroughDuplex(body.stream, {
+          evaluate: () => compressTransform(algorithm, options)
+        }), response.headers["content-type"] ?? body.contentType)));
+      }
+      case "Raw": {
+        const readable = body.body instanceof Readable ? body.body : Readable.fromWeb(new Response(body.body).body);
+        const transform = compressTransform(algorithm, options);
+        readable.on("error", (cause) => transform.destroy(cause));
+        transform.on("error", (cause) => readable.destroy(cause));
+        transform.on("close", () => readable.destroy());
+        return Effect.succeed(compressedBody(response, HttpBody.raw(readable.pipe(transform), {
+          contentType: response.headers["content-type"] ?? body.contentType
+        })));
+      }
+      default: {
+        return Effect.succeed(response);
+      }
+    }
+  }
+});
+var make3 = /* @__PURE__ */ Platform.make({
+  platform: "node",
+  compression,
+  fileResponse(path, status, statusText, headers, start, end, contentLength) {
+    const stream2 = contentLength === BigInt(0) ? Readable.from([]) : Fs.createReadStream(path, {
+      start,
+      end: end === void 0 ? void 0 : end - 1
+    });
+    return ServerResponse.raw(stream2, {
+      headers: {
+        ...headers,
+        "content-type": headers["content-type"] ?? Option.getOrElse(Mime.getType(path), () => "application/octet-stream"),
+        "content-length": contentLength.toString()
+      },
+      status,
+      statusText
+    });
+  },
+  fileWebResponse(file, status, statusText, headers, _options) {
+    return ServerResponse.raw(Readable.fromWeb(file.stream()), {
+      headers: Headers.merge(headers, Headers.fromRecordUnsafe({
+        "content-type": headers["content-type"] ?? Option.getOrElse(Mime.getType(file.name), () => "application/octet-stream"),
+        "content-length": file.size.toString()
+      })),
+      status,
+      statusText
+    });
+  }
+});
+var layer3 = /* @__PURE__ */ pipe(/* @__PURE__ */ Layer.effect(Platform.HttpPlatform)(make3), /* @__PURE__ */ Layer.provide(layer), /* @__PURE__ */ Layer.provide(EtagImpl.layer));
+
+export {
+  make3 as make,
+  layer3 as layer,
+  NodeHttpPlatform_exports
+};

package/dist/vendor/chunk-MSWDMTAF.js

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-BKTBUBQY.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/BunFileSystem.js
+var BunFileSystem_exports = {};
+__export(BunFileSystem_exports, {
+  layer: () => layer2
+});
+var layer2 = layer;
+
+export {
+  layer2 as layer,
+  BunFileSystem_exports
+};