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

package/dist/vendor/chunk-6FSJ2PMW.js

@@ -0,0 +1,53 @@
+import {
+  layer
+} from "./chunk-S6QUQLBV.js";
+import {
+  makeNet
+} from "./chunk-C3PGUWW5.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.4_effect@4.0.4/node_modules/@effect/platform-node-shared/dist/NodeClusterSocket.js
+var NodeClusterSocket_exports = {};
+__export(NodeClusterSocket_exports, {
+  layerClientProtocol: () => layerClientProtocol,
+  layerSocketServer: () => layerSocketServer
+});
+import * as Runners from "effect/cluster/Runners";
+import * as ShardingConfig from "effect/cluster/ShardingConfig";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as RpcClient from "effect/rpc/RpcClient";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
+import { Socket } from "effect/socket/Socket";
+var layerClientProtocol = /* @__PURE__ */ Layer.effect(Runners.RpcClientProtocol)(/* @__PURE__ */ Effect.gen(function* () {
+  const serialization = yield* RpcSerialization.RpcSerialization;
+  return {
+    codecFor: serialization.codecFor,
+    make: Effect.fnUntraced(function* (address) {
+      const socket = yield* makeNet({
+        openTimeout: 1e3,
+        timeout: 5500,
+        host: address.host,
+        port: address.port
+      });
+      return yield* RpcClient.makeProtocolSocket().pipe(Effect.provideService(Socket, socket), Effect.provideService(RpcSerialization.RpcSerialization, serialization));
+    }, Effect.orDie)
+  };
+}));
+var layerSocketServer = /* @__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("layerSocketServer: ShardingConfig.runnerListenAddress is None");
+  }
+  return layer(listenAddress.value);
+}).pipe(Layer.unwrap);
+
+export {
+  layerClientProtocol,
+  layerSocketServer,
+  NodeClusterSocket_exports
+};

package/dist/vendor/chunk-6L2NJEOV.js

@@ -0,0 +1,62 @@
+import {
+  NetSocket,
+  NodeWS,
+  fromDuplex,
+  layerNet,
+  layerTls,
+  makeNet,
+  makeNetChannel,
+  makeTls,
+  makeTlsChannel
+} from "./chunk-C3PGUWW5.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.4_effect@4.0.4_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeSocket.js
+var NodeSocket_exports = {};
+__export(NodeSocket_exports, {
+  NetSocket: () => NetSocket,
+  NodeWS: () => NodeWS,
+  fromDuplex: () => fromDuplex,
+  layerNet: () => layerNet,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  layerWebSocketConstructor: () => layerWebSocketConstructor,
+  layerWebSocketConstructorWS: () => layerWebSocketConstructorWS,
+  makeNet: () => makeNet,
+  makeNetChannel: () => makeNetChannel,
+  makeTls: () => makeTls,
+  makeTlsChannel: () => makeTlsChannel
+});
+import { flow } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Socket from "effect/socket/Socket";
+var makeWebSocketWS = (url, options) => {
+  if (options === void 0 || typeof options === "string" || Array.isArray(options)) {
+    return new NodeWS.WebSocket(url, options);
+  }
+  return new NodeWS.WebSocket(url, options.protocols, {
+    headers: options.headers
+  });
+};
+var layerWebSocketConstructor = /* @__PURE__ */ Layer.sync(Socket.WebSocketConstructor)(() => {
+  if ("WebSocket" in globalThis) {
+    return (url, options) => {
+      if (options === void 0 || typeof options === "string" || Array.isArray(options)) {
+        return new globalThis.WebSocket(url, options);
+      }
+      return makeWebSocketWS(url, options);
+    };
+  }
+  return makeWebSocketWS;
+});
+var layerWebSocketConstructorWS = /* @__PURE__ */ Layer.succeed(Socket.WebSocketConstructor)(makeWebSocketWS);
+var layerWebSocket = /* @__PURE__ */ flow(Socket.makeWebSocket, /* @__PURE__ */ Layer.effect(Socket.Socket), /* @__PURE__ */ Layer.provide(layerWebSocketConstructor));
+
+export {
+  layerWebSocketConstructor,
+  layerWebSocketConstructorWS,
+  layerWebSocket,
+  NodeSocket_exports
+};

package/dist/vendor/chunk-72X6VEVD.js

@@ -0,0 +1,62 @@
+import {
+  layer as layer2
+} from "./chunk-Y7V6ISZS.js";
+import {
+  layerWebSocketConstructor
+} from "./chunk-6L2NJEOV.js";
+import {
+  layerK8sHttpClient
+} from "./chunk-A7AY2JP7.js";
+import {
+  layerUndici
+} from "./chunk-UPIQ52FQ.js";
+import {
+  layer
+} from "./chunk-PU7QVYND.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.4_effect@4.0.4_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 HttpRunner from "effect/cluster/HttpRunner";
+import * as MessageStorage from "effect/cluster/MessageStorage";
+import * as RunnerHealth from "effect/cluster/RunnerHealth";
+import * as Runners from "effect/cluster/Runners";
+import * as RunnerStorage from "effect/cluster/RunnerStorage";
+import * as ShardingConfig from "effect/cluster/ShardingConfig";
+import * as SqlMessageStorage from "effect/cluster/SqlMessageStorage";
+import * as SqlRunnerStorage from "effect/cluster/SqlRunnerStorage";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as RpcSerialization from "effect/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-7NMJM44J.js

@@ -0,0 +1,26 @@
+import {
+  layer,
+  layerPosix,
+  layerWin32
+} from "./chunk-OF3N2FN4.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.4_effect@4.0.4_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-A7AY2JP7.js

@@ -0,0 +1,71 @@
+import {
+  Dispatcher,
+  layerUndiciNoDispatcher,
+  makeDispatcher
+} from "./chunk-UPIQ52FQ.js";
+import {
+  layer as layer2
+} from "./chunk-VIWU4EBF.js";
+import {
+  layer
+} from "./chunk-PU7QVYND.js";
+import {
+  layerClientProtocol,
+  layerSocketServer
+} from "./chunk-6FSJ2PMW.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.4_effect@4.0.4_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeClusterSocket.js
+var NodeClusterSocket_exports = {};
+__export(NodeClusterSocket_exports, {
+  layer: () => layer7,
+  layerClientProtocol: () => layerClientProtocol,
+  layerDispatcherK8s: () => layerDispatcherK8s,
+  layerK8sHttpClient: () => layerK8sHttpClient,
+  layerSocketServer: () => layerSocketServer
+});
+import * as K8sHttpClient from "effect/cluster/K8sHttpClient";
+import * as MessageStorage from "effect/cluster/MessageStorage";
+import * as RunnerHealth from "effect/cluster/RunnerHealth";
+import * as Runners from "effect/cluster/Runners";
+import * as RunnerStorage from "effect/cluster/RunnerStorage";
+import * as ShardingConfig from "effect/cluster/ShardingConfig";
+import * as SocketRunner from "effect/cluster/SocketRunner";
+import * as SqlMessageStorage from "effect/cluster/SqlMessageStorage";
+import * as SqlRunnerStorage from "effect/cluster/SqlRunnerStorage";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
+var layer7 = (options) => {
+  const layer8 = options?.clientOnly ? Layer.provide(SocketRunner.layerClientOnly, layerClientProtocol) : Layer.provide(SocketRunner.layer, [layerSocketServer, layerClientProtocol]);
+  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(layerClientProtocol));
+  return layer8.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 layerDispatcherK8s = /* @__PURE__ */ Layer.effect(Dispatcher)(Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const caCertOption = yield* fs.readFileString("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt").pipe(Effect.option);
+  if (caCertOption._tag === "Some") {
+    const Undici = yield* Effect.promise(() => import("./node/Undici.js"));
+    return yield* Effect.acquireRelease(Effect.sync(() => new Undici.Agent({
+      connect: {
+        ca: caCertOption.value
+      }
+    })), (agent) => Effect.promise(() => agent.destroy()));
+  }
+  return yield* makeDispatcher;
+})).pipe(/* @__PURE__ */ Layer.provide(layer2));
+var layerK8sHttpClient = /* @__PURE__ */ K8sHttpClient.layer.pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ Layer.fresh(layerUndiciNoDispatcher)), /* @__PURE__ */ Layer.provide(layerDispatcherK8s), /* @__PURE__ */ Layer.provide(layer2));
+
+export {
+  layer7 as layer,
+  layerDispatcherK8s,
+  layerK8sHttpClient,
+  NodeClusterSocket_exports
+};

package/dist/vendor/chunk-A7UXCEJA.js

@@ -0,0 +1,81 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.4_effect@4.0.4/node_modules/@effect/platform-node-shared/dist/NodeSink.js
+var NodeSink_exports = {};
+__export(NodeSink_exports, {
+  fromWritable: () => fromWritable,
+  fromWritableChannel: () => fromWritableChannel,
+  pullIntoWritable: () => pullIntoWritable
+});
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Effect from "effect/Effect";
+import { identity } from "effect/Function";
+import * as Pull from "effect/Pull";
+import * as Sink from "effect/Sink";
+var fromWritable = (options) => Sink.fromChannel(Channel.mapDone(fromWritableChannel(options), (_) => [_]));
+var fromWritableChannel = (options) => Channel.fromTransform((pull) => {
+  const writable = options.evaluate();
+  return Effect.succeed(pullIntoWritable({
+    ...options,
+    writable,
+    pull
+  }));
+});
+var pullIntoWritable = (options) => options.pull.pipe(Effect.flatMap((chunk) => {
+  let i = 0;
+  return Effect.callback((resume) => {
+    let cancelled = false;
+    const loop = () => {
+      for (; i < chunk.length; ) {
+        if (cancelled) {
+          return;
+        }
+        const success = options.writable.write(chunk[i++], options.encoding);
+        if (!success) {
+          if (!cancelled) {
+            options.writable.once("drain", loop);
+          }
+          return;
+        }
+      }
+      if (!cancelled) {
+        resume(Effect.void);
+      }
+    };
+    loop();
+    return Effect.sync(() => {
+      cancelled = true;
+      options.writable.off("drain", loop);
+    });
+  });
+}), Effect.forever({
+  disableYield: true
+}), options.endOnDone !== false ? Pull.catchDone((_) => {
+  if ("closed" in options.writable && options.writable.closed) {
+    return Cause.done(_);
+  }
+  return Effect.callback((resume) => {
+    const onFinish = () => resume(Cause.done(_));
+    options.writable.once("finish", onFinish);
+    options.writable.end();
+    return Effect.sync(() => {
+      options.writable.off("finish", onFinish);
+    });
+  });
+}) : identity, Effect.raceFirst(Effect.callback((resume) => {
+  const onError = (error) => resume(Effect.fail(options.onError(error)));
+  options.writable.once("error", onError);
+  return Effect.sync(() => {
+    options.writable.off("error", onError);
+  });
+})));
+
+export {
+  fromWritable,
+  fromWritableChannel,
+  pullIntoWritable,
+  NodeSink_exports
+};

package/dist/vendor/chunk-ADP5LRUF.js

@@ -0,0 +1,274 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.4_effect@4.0.4/node_modules/@effect/platform-node-shared/dist/NodeDns.js
+var NodeDns_exports = {};
+__export(NodeDns_exports, {
+  addressesFromLookup: () => addressesFromLookup,
+  dnsErrorFromCause: () => dnsErrorFromCause,
+  domainNameFromResolverUnsafe: () => domainNameFromResolverUnsafe,
+  layer: () => layer,
+  layerConfig: () => layerConfig,
+  lookup: () => lookup,
+  make: () => make2,
+  nameTextFromResolver: () => nameTextFromResolver,
+  recordsFromResolver: () => recordsFromResolver,
+  resolver: () => resolver,
+  secondsFromInt32: () => secondsFromInt32,
+  toFamily: () => toFamily,
+  utf8FromLatin1: () => utf8FromLatin1
+});
+import * as Arr from "effect/Array";
+import * as Config from "effect/Config";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Dns from "effect/net/Dns";
+import * as Host from "effect/net/Host";
+import * as NetAddress from "effect/net/NetAddress";
+import * as Result from "effect/Result";
+import * as NodeDns from "node:dns";
+var reasons = {
+  ENOTFOUND: "NotFound",
+  ENODATA: "NotFound",
+  ETIMEOUT: "Timeout",
+  // `getaddrinfo` reports SERVFAIL answers as `EAI_AGAIN`, and REFUSED,
+  // FORMERR, and NOTIMP answers alike as `EAI_FAIL`.
+  EAI_AGAIN: "Temporary",
+  EAI_FAIL: "Refused",
+  ESERVFAIL: "ServerFailure",
+  EREFUSED: "Refused",
+  ECONNREFUSED: "Refused",
+  EBADNAME: "BadName",
+  ENONAME: "BadName",
+  EBADFAMILY: "BadName",
+  EBADQUERY: "BadName",
+  EFORMERR: "InvalidResponse",
+  EBADRESP: "InvalidResponse",
+  ENOTIMP: "Unsupported"
+};
+var dnsErrorFromCause = (cause, method, hostname, recordType) => {
+  const code = typeof cause === "object" && cause !== null && "code" in cause ? String(cause.code).replace(/^DNS_/, "") : void 0;
+  return new Dns.DnsError({
+    reason: (code !== void 0 ? reasons[code] : void 0) ?? "Unknown",
+    method,
+    hostname,
+    recordType,
+    cause
+  });
+};
+var absoluteName = (name) => {
+  if (name.endsWith(".")) {
+    let backslashes = 0;
+    for (let i = name.length - 2; i >= 0 && name[i] === "\\"; i--) {
+      backslashes++;
+    }
+    if (backslashes % 2 === 0) return name;
+  }
+  return `${name}.`;
+};
+var domainNameFromResolverUnsafe = (name) => Host.domainNameFromStringUnsafe(absoluteName(name));
+var decoder = /* @__PURE__ */ new TextDecoder();
+var encoder = /* @__PURE__ */ new TextEncoder();
+var nameParts = /\\(\d{3})|\\(.)|[^\\]+|\\/gsu;
+var nameTextFromResolver = (name, radix = 10) => {
+  if (!name.includes("\\")) return absoluteName(name);
+  const bytes = [];
+  for (const [part, digits, escaped] of name.matchAll(nameParts)) {
+    if (digits !== void 0) {
+      const byte = Number.parseInt(digits, radix);
+      if (byte === 46 || byte === 92) bytes.push(92);
+      bytes.push(byte);
+    } else if (escaped !== void 0) {
+      if (escaped === "." || escaped === "\\") bytes.push(92);
+      bytes.push(...encoder.encode(escaped));
+    } else {
+      bytes.push(...encoder.encode(part));
+    }
+  }
+  return absoluteName(decoder.decode(Uint8Array.from(bytes)));
+};
+var secondsFromInt32 = (value) => Duration.seconds(value >>> 0);
+var utf8FromLatin1 = (value) => (
+  // oxlint-disable-next-line no-control-regex
+  /[^\x00-\x7f]/.test(value) ? decoder.decode(Uint8Array.from(value, (character) => character.charCodeAt(0))) : value
+);
+var recordsFromResolver = (name, type, entries, fields) => {
+  const records = [];
+  let skipped;
+  for (const entry of entries) {
+    const result = Result.try(() => Dns.makeRecordUnsafe(type, fields(entry)));
+    if (Result.isSuccess(result)) {
+      records.push(result.success);
+    } else {
+      skipped ??= result;
+    }
+  }
+  return records.length === 0 && skipped !== void 0 ? Result.fail(new Dns.DnsError({
+    reason: "InvalidResponse",
+    method: "resolve",
+    hostname: name,
+    recordType: type,
+    cause: skipped.failure
+  })) : Result.succeed(records);
+};
+var queries = {
+  A: async (resolver2, name) => recordsFromResolver(name, "A", await resolver2.resolve4(name), (address) => ({
+    address: NetAddress.ipFromStringUnsafe(address)
+  })),
+  AAAA: async (resolver2, name) => recordsFromResolver(name, "AAAA", await resolver2.resolve6(name), (address) => ({
+    address: NetAddress.ipFromStringUnsafe(address)
+  })),
+  CAA: async (resolver2, name) => recordsFromResolver(name, "CAA", await resolver2.resolveCaa(name), (caa) => {
+    const tag = Object.keys(caa).find((key) => key !== "critical" && key !== "type");
+    if (tag === void 0) throw new Error("CAA record without a property tag");
+    return {
+      critical: (caa.critical & 128) !== 0,
+      tag,
+      value: String(caa[tag])
+    };
+  }),
+  CNAME: async (resolver2, name) => recordsFromResolver(name, "CNAME", await resolver2.resolveCname(name), (target) => ({
+    target: domainNameFromResolverUnsafe(target)
+  })),
+  MX: async (resolver2, name) => recordsFromResolver(name, "MX", await resolver2.resolveMx(name), (mx) => ({
+    exchange: domainNameFromResolverUnsafe(mx.exchange),
+    priority: mx.priority
+  })),
+  NAPTR: async (resolver2, name) => recordsFromResolver(name, "NAPTR", await resolver2.resolveNaptr(name), (naptr) => ({
+    order: naptr.order,
+    preference: naptr.preference,
+    flags: naptr.flags,
+    service: naptr.service,
+    regexp: naptr.regexp,
+    replacement: domainNameFromResolverUnsafe(naptr.replacement)
+  })),
+  NS: async (resolver2, name) => recordsFromResolver(name, "NS", await resolver2.resolveNs(name), (host) => ({
+    host: domainNameFromResolverUnsafe(host)
+  })),
+  PTR: async (resolver2, name) => recordsFromResolver(name, "PTR", await resolver2.resolvePtr(name), (host) => ({
+    host: nameTextFromResolver(host)
+  })),
+  SOA: async (resolver2, name) => recordsFromResolver(name, "SOA", [await resolver2.resolveSoa(name)], (soa) => ({
+    primary: domainNameFromResolverUnsafe(soa.nsname),
+    admin: nameTextFromResolver(soa.hostmaster),
+    serial: soa.serial,
+    refresh: secondsFromInt32(soa.refresh),
+    retry: secondsFromInt32(soa.retry),
+    expire: secondsFromInt32(soa.expire),
+    minimum: Duration.seconds(soa.minttl)
+  })),
+  SRV: async (resolver2, name) => recordsFromResolver(name, "SRV", await resolver2.resolveSrv(name), (srv) => ({
+    target: domainNameFromResolverUnsafe(srv.name),
+    port: srv.port,
+    priority: srv.priority,
+    weight: srv.weight
+  })),
+  // `resolveTlsa` was added in Node.js 22.15 and 23.9; Bun and Deno lack it.
+  TLSA: async (resolver2, name) => typeof resolver2.resolveTlsa === "function" ? recordsFromResolver(name, "TLSA", await resolver2.resolveTlsa(name), (tlsa) => ({
+    certUsage: tlsa.certUsage,
+    selector: tlsa.selector,
+    matchingType: tlsa.match,
+    data: new Uint8Array(tlsa.data)
+  })) : Result.fail(new Dns.DnsError({
+    reason: "Unsupported",
+    method: "resolve",
+    hostname: name,
+    recordType: "TLSA"
+  })),
+  TXT: async (resolver2, name) => recordsFromResolver(name, "TXT", await resolver2.resolveTxt(name), (chunks) => ({
+    chunks
+  }))
+};
+var toFamily = (family) => family === "IPv4" ? 4 : family === "IPv6" ? 6 : 0;
+var stripZone = (address) => {
+  const separator = address.indexOf("%");
+  return separator === -1 ? address : address.slice(0, separator);
+};
+var addressesFromLookup = (entries) => Arr.filterMap(entries, (entry) => Result.try(() => NetAddress.ipFromStringUnsafe(stripZone(entry.address))));
+var lookup = (host, family) => Effect.tryPromise({
+  // `verbatim` keeps the system order on Node versions without `order`.
+  try: () => NodeDns.promises.lookup(host, {
+    all: true,
+    family: toFamily(family),
+    order: "verbatim",
+    verbatim: true
+  }),
+  catch: (cause) => dnsErrorFromCause(cause, "lookup", host)
+}).pipe(Effect.map(addressesFromLookup));
+var resolverInt = (value) => value >= 1 ? Math.min(value, 2 ** 31 - 1) : 1;
+var resolver = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const resolverOptions = {
+    ...options?.timeout !== void 0 && {
+      timeout: resolverInt(Math.ceil(Duration.toMillis(options.timeout)))
+    },
+    ...options?.tries !== void 0 && {
+      tries: resolverInt(Math.floor(options.tries))
+    }
+  };
+  const nameServers = [];
+  for (const input of options?.nameServers ?? []) {
+    const server = yield* Effect.fromResult(Dns.nameServerFromInput(input));
+    if (NetAddress.isInetAddressV6(server) && server.scopeId !== 0) {
+      return yield* new NetAddress.NetAddressError({
+        input,
+        message: "IPv6 name servers with a scope ID are not supported"
+      });
+    }
+    nameServers.push(server);
+  }
+  const resolver2 = yield* Effect.acquireRelease(Effect.sync(() => {
+    const resolver3 = new NodeDns.promises.Resolver(resolverOptions);
+    if (nameServers.length > 0) {
+      resolver3.setServers(nameServers.map(NetAddress.formatInet));
+    }
+    return resolver3;
+  }), (resolver3) => Effect.sync(() => resolver3.cancel()));
+  return (name, type) => Effect.tryPromise({
+    try: () => queries[type](resolver2, name),
+    catch: (cause) => dnsErrorFromCause(cause, "resolve", name, type)
+  }).pipe(Effect.flatMap(Effect.fromResult));
+});
+var utf8Strings = (record) => {
+  switch (record._tag) {
+    case "TXT":
+      return Dns.makeRecordUnsafe("TXT", {
+        chunks: Arr.map(record.chunks, utf8FromLatin1)
+      });
+    case "CAA":
+      return Dns.makeRecordUnsafe("CAA", {
+        critical: record.critical,
+        tag: record.tag,
+        value: utf8FromLatin1(record.value)
+      });
+    default:
+      return record;
+  }
+};
+var make2 = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const resolve = yield* resolver(options);
+  return Dns.make({
+    lookup,
+    resolve: (name, type) => Effect.map(resolve(name, type), Arr.map(utf8Strings))
+  });
+});
+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 {
+  dnsErrorFromCause,
+  domainNameFromResolverUnsafe,
+  nameTextFromResolver,
+  secondsFromInt32,
+  utf8FromLatin1,
+  recordsFromResolver,
+  toFamily,
+  addressesFromLookup,
+  lookup,
+  resolver,
+  make2 as make,
+  layer,
+  layerConfig,
+  NodeDns_exports
+};

package/dist/vendor/chunk-AWNTTSHL.js

@@ -0,0 +1,34 @@
+import {
+  fromDuplex,
+  fromReadable,
+  fromReadableChannel,
+  pipeThroughDuplex,
+  pipeThroughSimple,
+  toArrayBuffer,
+  toReadable,
+  toReadableNever,
+  toString,
+  toUint8Array
+} from "./chunk-RQH5DSBA.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.4_effect@4.0.4_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeStream.js
+var NodeStream_exports = {};
+__export(NodeStream_exports, {
+  fromDuplex: () => fromDuplex,
+  fromReadable: () => fromReadable,
+  fromReadableChannel: () => fromReadableChannel,
+  pipeThroughDuplex: () => pipeThroughDuplex,
+  pipeThroughSimple: () => pipeThroughSimple,
+  toArrayBuffer: () => toArrayBuffer,
+  toReadable: () => toReadable,
+  toReadableNever: () => toReadableNever,
+  toString: () => toString,
+  toUint8Array: () => toUint8Array
+});
+
+export {
+  NodeStream_exports
+};