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

package/dist/vendor/chunk-V577GRCI.js

@@ -0,0 +1,438 @@
+import {
+  NodeHttpIncomingMessage
+} from "./chunk-AMAL6TRE.js";
+import {
+  fromReadable,
+  toReadable
+} from "./chunk-T5WDTZCE.js";
+import {
+  fromWritable
+} from "./chunk-DX4VFONH.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeHttpClient.js
+var NodeHttpClient_exports = {};
+__export(NodeHttpClient_exports, {
+  Dispatcher: () => Dispatcher,
+  Fetch: () => Fetch,
+  HttpAgent: () => HttpAgent,
+  RequestInit: () => RequestInit,
+  UndiciOptions: () => UndiciOptions,
+  dispatcherLayerGlobal: () => dispatcherLayerGlobal,
+  layerAgent: () => layerAgent,
+  layerAgentOptions: () => layerAgentOptions,
+  layerDispatcher: () => layerDispatcher,
+  layerDispatcherOptions: () => layerDispatcherOptions,
+  layerFetch: () => layer,
+  layerNodeHttp: () => layerNodeHttp,
+  layerNodeHttpNoAgent: () => layerNodeHttpNoAgent,
+  layerNodeHttpOptions: () => layerNodeHttpOptions,
+  layerUndici: () => layerUndici,
+  layerUndiciNoDispatcher: () => layerUndiciNoDispatcher,
+  layerUndiciOptions: () => layerUndiciOptions,
+  makeAgent: () => makeAgent,
+  makeDispatcher: () => makeDispatcher,
+  makeDispatcherOptions: () => makeDispatcherOptions,
+  makeNodeHttp: () => makeNodeHttp,
+  makeUndici: () => makeUndici
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import { flow } from "effect/Function";
+import * as Cookies from "effect/http/Cookies";
+import * as Headers from "effect/http/Headers";
+import * as Client from "effect/http/HttpClient";
+import * as Error from "effect/http/HttpClientError";
+import * as Response from "effect/http/HttpClientResponse";
+import * as IncomingMessage from "effect/http/HttpIncomingMessage";
+import * as UrlParams from "effect/http/UrlParams";
+import * as Inspectable from "effect/Inspectable";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { pipeArguments } from "effect/Pipeable";
+import * as Stream from "effect/Stream";
+import * as Http from "node:http";
+import * as Https from "node:https";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import {
+  Fetch,
+  layer,
+  RequestInit
+} from "effect/http/FetchHttpClient";
+var Dispatcher = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node/NodeHttpClient/Dispatcher")) {
+};
+var loadUndici = /* @__PURE__ */ Effect.promise(() => import("./node/Undici.js"));
+var makeDispatcherOptions = (options) => Effect.acquireRelease(Effect.map(loadUndici, (_) => new _.Agent(options)), (dispatcher) => Effect.promise(() => dispatcher.destroy()));
+var makeDispatcher = /* @__PURE__ */ makeDispatcherOptions();
+var layerDispatcherOptions = /* @__PURE__ */ flow(makeDispatcherOptions, /* @__PURE__ */ Layer.effect(Dispatcher));
+var layerDispatcher = /* @__PURE__ */ layerDispatcherOptions();
+var dispatcherLayerGlobal = /* @__PURE__ */ Layer.effect(Dispatcher)(/* @__PURE__ */ Effect.map(loadUndici, (_) => _.getGlobalDispatcher()));
+var UndiciOptions = /* @__PURE__ */ Context.Reference("@effect/platform-node/NodeHttpClient/UndiciOptions", {
+  defaultValue: () => ({})
+});
+var makeUndici = /* @__PURE__ */ Effect.gen(function* () {
+  const dispatcher = yield* Dispatcher;
+  return Client.make((request3, url, signal, fiber) => convertBody(request3.body).pipe(Effect.flatMap((body) => Effect.tryPromise({
+    try: () => dispatcher.request({
+      ...fiber.getRef(UndiciOptions),
+      signal,
+      method: request3.method,
+      headers: request3.headers,
+      origin: url.origin,
+      path: url.pathname + url.search,
+      body,
+      // leave timeouts to Effect.timeout etc
+      headersTimeout: 60 * 60 * 1e3,
+      bodyTimeout: 0
+    }),
+    catch: (cause) => new Error.HttpClientError({
+      reason: new Error.TransportError({
+        request: request3,
+        cause
+      })
+    })
+  })), Effect.map((response) => new UndiciResponse(request3, response, url.href.split("#")[0]))));
+});
+function convertBody(body) {
+  switch (body._tag) {
+    case "Empty": {
+      return Effect.succeed(null);
+    }
+    case "Uint8Array":
+    case "Raw": {
+      return Effect.succeed(body.body);
+    }
+    case "FormData": {
+      return Effect.succeed(body.formData);
+    }
+    case "Stream": {
+      return toReadable(body.stream);
+    }
+  }
+}
+function noopErrorHandler(_) {
+}
+var UndiciResponse = class extends Inspectable.Class {
+  [IncomingMessage.TypeId];
+  [Response.TypeId];
+  request;
+  source;
+  url;
+  constructor(request3, source, url) {
+    super();
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId;
+    this[Response.TypeId] = Response.TypeId;
+    this.request = request3;
+    this.source = source;
+    this.url = url;
+    source.body.on("error", noopErrorHandler);
+  }
+  get status() {
+    return this.source.statusCode;
+  }
+  get statusText() {
+    return void 0;
+  }
+  get headers() {
+    return Headers.fromInput(this.source.headers);
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies !== void 0) {
+      return this.cachedCookies;
+    }
+    const header = this.source.headers["set-cookie"];
+    return this.cachedCookies = header ? Cookies.fromSetCookie(header) : Cookies.empty;
+  }
+  get remoteAddress() {
+    return Option.none();
+  }
+  get stream() {
+    return fromReadable({
+      evaluate: () => this.source.body,
+      onError: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    });
+  }
+  get json() {
+    return Effect.flatMap(this.text, (text) => Effect.try({
+      try: () => text === "" ? null : JSON.parse(text),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  textBody;
+  get text() {
+    if (this.textBody) {
+      return this.textBody;
+    }
+    this.textBody = Effect.map(this.arrayBuffer, (_) => new TextDecoder().decode(_));
+    return this.textBody;
+  }
+  get urlParamsBody() {
+    return Effect.flatMap(this.text, (_) => Effect.try({
+      try: () => UrlParams.fromInput(new URLSearchParams(_)),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  formDataBody;
+  get formData() {
+    return this.formDataBody ??= Effect.flatMap(this.arrayBuffer, (body) => Effect.tryPromise({
+      try: () => new globalThis.Response(body, {
+        headers: this.headers
+      }).formData(),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    })).pipe(Effect.cached, Effect.runSync);
+  }
+  arrayBufferBody;
+  get arrayBuffer() {
+    if (this.arrayBufferBody) {
+      return this.arrayBufferBody;
+    }
+    this.arrayBufferBody = Effect.tryPromise({
+      try: () => this.source.body.arrayBuffer(),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }).pipe(Effect.cached, Effect.runSync);
+    this.textBody = Effect.map(this.arrayBufferBody, (_) => new TextDecoder().decode(_));
+    return this.arrayBufferBody;
+  }
+  toJSON() {
+    return IncomingMessage.inspect(this, {
+      _id: "effect/http/HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    });
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var layerUndiciNoDispatcher = /* @__PURE__ */ Client.layerMergedContext(makeUndici);
+var layerUndici = /* @__PURE__ */ Layer.provide(layerUndiciNoDispatcher, layerDispatcher);
+var layerUndiciOptions = (options) => Layer.provide(layerUndiciNoDispatcher, layerDispatcherOptions(options));
+var HttpAgent = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node/NodeHttpClient/HttpAgent")) {
+};
+var makeAgent = (options) => Effect.zipWith(Effect.acquireRelease(Effect.sync(() => new Http.Agent(options)), (agent) => Effect.sync(() => agent.destroy())), Effect.acquireRelease(Effect.sync(() => new Https.Agent(options)), (agent) => Effect.sync(() => agent.destroy())), (http, https) => ({
+  http,
+  https
+}));
+var layerAgentOptions = /* @__PURE__ */ flow(makeAgent, /* @__PURE__ */ Layer.effect(HttpAgent));
+var layerAgent = /* @__PURE__ */ layerAgentOptions();
+var makeNodeHttp = /* @__PURE__ */ Effect.gen(function* () {
+  const agent = yield* HttpAgent;
+  return Client.make((request3, url, signal) => {
+    const nodeRequest = url.protocol === "https:" ? Https.request(url, {
+      agent: agent.https,
+      method: request3.method,
+      headers: request3.headers,
+      signal
+    }) : Http.request(url, {
+      agent: agent.http,
+      method: request3.method,
+      headers: request3.headers,
+      signal
+    });
+    return Effect.raceFirst(waitForResponse(nodeRequest, request3), sendBody(nodeRequest, request3, request3.body).pipe(Effect.andThen(Effect.never))).pipe(Effect.onError(() => Effect.sync(() => nodeRequest.destroy())), Effect.map((_) => new NodeHttpResponse(request3, _, url.href.split("#")[0])));
+  });
+});
+var sendBody = (nodeRequest, request3, body) => Effect.suspend(() => {
+  switch (body._tag) {
+    case "Empty": {
+      nodeRequest.end();
+      return waitForFinish(nodeRequest, request3);
+    }
+    case "Uint8Array":
+    case "Raw": {
+      nodeRequest.end(body.body);
+      return waitForFinish(nodeRequest, request3);
+    }
+    case "FormData": {
+      const response = new globalThis.Response(body.formData);
+      response.headers.forEach((value, key) => {
+        nodeRequest.setHeader(key, value);
+      });
+      return Effect.tryPromise({
+        try: () => pipeline(Readable.fromWeb(response.body), nodeRequest),
+        catch: (cause) => new Error.HttpClientError({
+          reason: new Error.TransportError({
+            request: request3,
+            cause
+          })
+        })
+      });
+    }
+    case "Stream": {
+      return Stream.run(Stream.mapError(body.stream, (cause) => new Error.HttpClientError({
+        reason: new Error.EncodeError({
+          request: request3,
+          cause
+        })
+      })), fromWritable({
+        evaluate: () => nodeRequest,
+        onError: (cause) => new Error.HttpClientError({
+          reason: new Error.TransportError({
+            request: request3,
+            cause
+          })
+        })
+      }));
+    }
+  }
+});
+var waitForResponse = (nodeRequest, request3) => Effect.callback((resume) => {
+  function onError2(cause) {
+    resume(Effect.fail(new Error.HttpClientError({
+      reason: new Error.TransportError({
+        request: request3,
+        cause
+      })
+    })));
+  }
+  nodeRequest.on("error", onError2);
+  function onResponse(response) {
+    nodeRequest.off("error", onError2);
+    resume(Effect.succeed(response));
+  }
+  nodeRequest.on("upgrade", onResponse);
+  nodeRequest.on("response", onResponse);
+  return Effect.sync(() => {
+    nodeRequest.off("error", onError2);
+    nodeRequest.off("upgrade", onResponse);
+    nodeRequest.off("response", onResponse);
+  });
+});
+var waitForFinish = (nodeRequest, request3) => Effect.callback((resume) => {
+  function onError2(cause) {
+    resume(Effect.fail(new Error.HttpClientError({
+      reason: new Error.TransportError({
+        request: request3,
+        cause
+      })
+    })));
+  }
+  nodeRequest.once("error", onError2);
+  function onFinish() {
+    nodeRequest.off("error", onError2);
+    resume(Effect.void);
+  }
+  nodeRequest.once("finish", onFinish);
+  return Effect.sync(() => {
+    nodeRequest.off("error", onError2);
+    nodeRequest.off("finish", onFinish);
+  });
+});
+var NodeHttpResponse = class extends NodeHttpIncomingMessage {
+  [Response.TypeId];
+  request;
+  url;
+  constructor(request3, source, url) {
+    super(source, (cause) => new Error.HttpClientError({
+      reason: new Error.DecodeError({
+        request: request3,
+        response: this,
+        cause
+      })
+    }));
+    this[Response.TypeId] = Response.TypeId;
+    this.request = request3;
+    this.url = url;
+  }
+  get status() {
+    return this.source.statusCode;
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies !== void 0) {
+      return this.cachedCookies;
+    }
+    const header = this.source.headers["set-cookie"];
+    return this.cachedCookies = header ? Cookies.fromSetCookie(header) : Cookies.empty;
+  }
+  get formData() {
+    return Effect.tryPromise({
+      try: () => {
+        const init = {
+          headers: new globalThis.Headers(this.source.headers)
+        };
+        if (this.source.statusCode) {
+          init.status = this.source.statusCode;
+        }
+        if (this.source.statusMessage) {
+          init.statusText = this.source.statusMessage;
+        }
+        return new globalThis.Response(Readable.toWeb(this.source), init).formData();
+      },
+      catch: this.onError
+    });
+  }
+  toJSON() {
+    return IncomingMessage.inspect(this, {
+      _id: "effect/http/HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    });
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var layerNodeHttpNoAgent = /* @__PURE__ */ Client.layerMergedContext(makeNodeHttp);
+var layerNodeHttp = /* @__PURE__ */ Layer.provide(layerNodeHttpNoAgent, layerAgent);
+var layerNodeHttpOptions = (options) => Layer.provide(layerNodeHttpNoAgent, layerAgentOptions(options));
+
+export {
+  Dispatcher,
+  makeDispatcherOptions,
+  makeDispatcher,
+  layerDispatcherOptions,
+  layerDispatcher,
+  dispatcherLayerGlobal,
+  UndiciOptions,
+  makeUndici,
+  layerUndiciNoDispatcher,
+  layerUndici,
+  layerUndiciOptions,
+  HttpAgent,
+  makeAgent,
+  layerAgentOptions,
+  layerAgent,
+  makeNodeHttp,
+  layerNodeHttpNoAgent,
+  layerNodeHttp,
+  layerNodeHttpOptions,
+  NodeHttpClient_exports,
+  Fetch,
+  layer,
+  RequestInit
+};

package/dist/vendor/chunk-VS6VBUH6.js

@@ -0,0 +1,57 @@
+import {
+  make
+} from "./chunk-PBM2HJOX.js";
+import {
+  layer
+} from "./chunk-QR2ZOVOL.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.5_effect@4.0.5/node_modules/@effect/platform-bun/dist/BunHttpPlatform.js
+var BunHttpPlatform_exports = {};
+__export(BunHttpPlatform_exports, {
+  layer: () => layer3
+});
+import * as Etag from "effect/http/Etag";
+import * as Platform from "effect/http/HttpPlatform";
+import * as Response from "effect/http/HttpServerResponse";
+import * as Layer from "effect/Layer";
+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-WGUQHMX2.js

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-226TYKP6.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeStdio.js
+var NodeStdio_exports = {};
+__export(NodeStdio_exports, {
+  layer: () => layer2
+});
+var layer2 = layer;
+
+export {
+  layer2 as layer,
+  NodeStdio_exports
+};

package/dist/vendor/chunk-WNS3OER2.js

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-7JOAEKDV.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_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-X6FYP2EH.js

@@ -0,0 +1,109 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeMultipartParser.js
+var NodeMultipartParser_exports = {};
+__export(NodeMultipartParser_exports, {
+  FileStream: () => FileStream,
+  MultipartStream: () => MultipartStream,
+  make: () => make
+});
+import { make as makeParser } from "effect/http/MultipartParser";
+import { Duplex, Readable } from "node:stream";
+var MultipartStream = class extends Duplex {
+  _parser;
+  _canWrite = true;
+  _writeCallback;
+  constructor(config) {
+    super({
+      readableObjectMode: true
+    });
+    let currentError;
+    let currentFile;
+    this._parser = makeParser({
+      ...config,
+      onField: (info, value) => {
+        if (currentError !== void 0) return;
+        const field = {
+          _tag: "Field",
+          info,
+          value
+        };
+        this.push(field);
+        this.emit("field", field);
+      },
+      onFile: (info) => {
+        if (currentError !== void 0) return (_) => {
+        };
+        const file = new FileStream(info, this);
+        currentFile = file;
+        this.push(file);
+        this.emit("file", file);
+        return (chunk) => {
+          if (currentError !== void 0) return;
+          this._canWrite = file.push(chunk);
+          if (chunk === null && !this._canWrite) {
+            currentFile = void 0;
+            this._resume();
+          }
+        };
+      },
+      onError: (error) => {
+        this.emit("error", error);
+        currentFile?.emit("error", error);
+        currentError = error;
+      },
+      onDone: () => {
+        this.push(null);
+      }
+    });
+  }
+  _resume() {
+    this._canWrite = true;
+    if (this._writeCallback !== void 0) {
+      const callback = this._writeCallback;
+      this._writeCallback = void 0;
+      callback();
+    }
+  }
+  _read(_size) {
+  }
+  _write(chunk, encoding, callback) {
+    this._parser.write(chunk instanceof Uint8Array ? chunk : Buffer.from(chunk, encoding));
+    if (this._canWrite) {
+      callback();
+    } else {
+      this._writeCallback = callback;
+    }
+  }
+  _final(callback) {
+    this._parser.end();
+    callback();
+  }
+};
+var make = (config) => new MultipartStream(config);
+var FileStream = class extends Readable {
+  _tag = "File";
+  filename;
+  info;
+  _parent;
+  constructor(info, parent) {
+    super();
+    this.info = info;
+    this._parent = parent;
+    this.filename = info.filename;
+  }
+  _read(_size) {
+    if (this._parent._canWrite === false) {
+      this._parent._resume();
+    }
+  }
+};
+
+export {
+  MultipartStream,
+  make,
+  FileStream,
+  NodeMultipartParser_exports
+};

package/dist/vendor/chunk-XAVBQY4D.js

@@ -0,0 +1,20 @@
+import {
+  fromWritable,
+  fromWritableChannel,
+  pullIntoWritable
+} from "./chunk-DX4VFONH.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeSink.js
+var NodeSink_exports = {};
+__export(NodeSink_exports, {
+  fromWritable: () => fromWritable,
+  fromWritableChannel: () => fromWritableChannel,
+  pullIntoWritable: () => pullIntoWritable
+});
+
+export {
+  NodeSink_exports
+};

package/dist/vendor/chunk-XAZH2ZEU.js

@@ -0,0 +1,43 @@
+import {
+  addressesFromLookup,
+  dnsErrorFromCause,
+  resolver,
+  toFamily
+} from "./chunk-R2PFJKSP.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.5_effect@4.0.5/node_modules/@effect/platform-bun/dist/BunDns.js
+var BunDns_exports = {};
+__export(BunDns_exports, {
+  layer: () => layer,
+  layerConfig: () => layerConfig,
+  make: () => make2
+});
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Dns from "effect/net/Dns";
+var make2 = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const resolve = yield* resolver(options);
+  return Dns.make({
+    lookup: (host, family) => Effect.tryPromise({
+      try: () => Bun.dns.lookup(host, {
+        family: toFamily(family),
+        backend: "system"
+      }),
+      catch: (cause) => dnsErrorFromCause(cause, "lookup", host)
+    }).pipe(Effect.map(addressesFromLookup)),
+    resolve
+  });
+});
+var layer = /* @__PURE__ */ Layer.effect(Dns.Dns, /* @__PURE__ */ Effect.orDie(/* @__PURE__ */ make2()));
+var layerConfig = (options) => Layer.effect(Dns.Dns, Effect.flatMap(Config.unwrap(options), make2));
+
+export {
+  make2 as make,
+  layer,
+  layerConfig,
+  BunDns_exports
+};