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

package/dist/vendor/chunk-R2PFJKSP.js

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

@@ -0,0 +1,51 @@
+import {
+  NetSocket,
+  NodeWS,
+  fromDuplex,
+  layerNet,
+  layerTls,
+  makeNet,
+  makeNetChannel,
+  makeTls,
+  makeTlsChannel
+} from "./chunk-Q7YXUH7M.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/BunSocket.js
+var BunSocket_exports = {};
+__export(BunSocket_exports, {
+  NetSocket: () => NetSocket,
+  NodeWS: () => NodeWS,
+  fromDuplex: () => fromDuplex,
+  layerNet: () => layerNet,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  layerWebSocketConstructor: () => layerWebSocketConstructor,
+  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 layerWebSocketConstructor = /* @__PURE__ */ Layer.succeed(Socket.WebSocketConstructor)((url, options) => {
+  if (options === void 0 || typeof options === "string" || Array.isArray(options)) {
+    return new globalThis.WebSocket(url, options);
+  }
+  const WebSocket = globalThis.WebSocket;
+  return new WebSocket(url, {
+    // Bun requires a sequence for `protocols` in its options object.
+    protocols: typeof options.protocols === "string" ? [options.protocols] : options.protocols,
+    headers: options.headers
+  });
+});
+var layerWebSocket = /* @__PURE__ */ flow(Socket.makeWebSocket, /* @__PURE__ */ Layer.effect(Socket.Socket), /* @__PURE__ */ Layer.provide(layerWebSocketConstructor));
+
+export {
+  layerWebSocketConstructor,
+  layerWebSocket,
+  BunSocket_exports
+};

package/dist/vendor/chunk-S3MN5OXB.js

@@ -0,0 +1,34 @@
+import {
+  fromDuplex,
+  fromReadable,
+  fromReadableChannel,
+  pipeThroughDuplex,
+  pipeThroughSimple,
+  toArrayBuffer,
+  toReadable,
+  toReadableNever,
+  toString,
+  toUint8Array
+} from "./chunk-T5WDTZCE.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/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
+};

package/dist/vendor/chunk-T5WDTZCE.js

@@ -0,0 +1,249 @@
+import {
+  pullIntoWritable
+} from "./chunk-DX4VFONH.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.5_effect@4.0.5/node_modules/@effect/platform-node-shared/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
+});
+import * as Arr from "effect/Array";
+import * as ByteSize from "effect/ByteSize";
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
+import * as Latch from "effect/Latch";
+import * as MutableRef from "effect/MutableRef";
+import * as Pull from "effect/Pull";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import { Readable } from "node:stream";
+var fromReadable = (options) => Stream.fromChannel(fromReadableChannel(options));
+var fromReadableChannel = (options) => Channel.fromTransform((_, scope) => readableToPullUnsafe({
+  scope,
+  readable: options.evaluate(),
+  onError: options.onError ?? defaultOnError,
+  chunkSize: options.chunkSize,
+  closeOnDone: options.closeOnDone
+}));
+var fromDuplex = (options) => Channel.fromTransform((upstream, scope) => {
+  const duplex = options.evaluate();
+  const exit = MutableRef.make(void 0);
+  const latch = Latch.makeUnsafe(false);
+  return pullIntoWritable({
+    pull: upstream,
+    writable: duplex,
+    onError: options.onError ?? defaultOnError,
+    endOnDone: options.endOnDone,
+    encoding: options.encoding
+  }).pipe(Effect.catchCause((cause) => {
+    if (Pull.isDoneCause(cause)) return Effect.void;
+    exit.current = Exit.failCause(cause);
+    latch.openUnsafe();
+    return Effect.void;
+  }), Effect.forkIn(scope), Effect.flatMap(() => readableToPullUnsafe({
+    scope,
+    exit,
+    latch,
+    readable: duplex,
+    onError: options.onError ?? defaultOnError,
+    chunkSize: options.chunkSize
+  })));
+});
+var pipeThroughDuplex = /* @__PURE__ */ dual(2, (self, options) => Stream.pipeThroughChannelOrFail(self, fromDuplex(options)));
+var pipeThroughSimple = /* @__PURE__ */ dual(2, (self, duplex) => pipeThroughDuplex(self, {
+  evaluate: duplex
+}));
+var toReadable = (stream) => Effect.map(Effect.context(), (context2) => new StreamAdapter(context2, stream));
+var toReadableNever = (stream) => new StreamAdapter(Context.empty(), stream);
+var toString = (readable, options) => {
+  const maxBytesNumber = toMaxBytes(options?.maxBytes);
+  const onError = options?.onError ?? defaultOnError;
+  const encoding = options?.encoding ?? "utf8";
+  return Effect.callback((resume) => {
+    const stream = readable();
+    stream.setEncoding(encoding);
+    stream.once("error", (err) => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+      resume(Effect.fail(onError(err)));
+    });
+    let string = "";
+    let bytes = 0;
+    stream.once("end", () => {
+      resume(Effect.succeed(string));
+    });
+    stream.on("data", (chunk) => {
+      string += chunk;
+      bytes += Buffer.byteLength(chunk);
+      if (maxBytesNumber !== void 0 && bytes > maxBytesNumber) {
+        if ("closed" in stream && !stream.closed) {
+          stream.destroy();
+        }
+        resume(Effect.fail(onError(new Error("maxBytes exceeded"))));
+      }
+    });
+    return Effect.sync(() => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+    });
+  });
+};
+var toArrayBuffer = (readable, options) => {
+  const maxBytesNumber = toMaxBytes(options?.maxBytes);
+  const onError = options?.onError ?? defaultOnError;
+  return Effect.callback((resume) => {
+    const stream = readable();
+    const buffers = [];
+    let bytes = 0;
+    stream.once("error", (err) => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+      resume(Effect.fail(onError(err)));
+    });
+    stream.once("end", () => {
+      const buffer = buffers.length === 1 ? buffers[0] : Buffer.concat(buffers);
+      if (buffer.byteOffset === 0 && buffer.buffer.byteLength === buffer.byteLength) {
+        return resume(Effect.succeed(buffer.buffer));
+      }
+      resume(Effect.succeed(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)));
+    });
+    stream.on("data", (chunk) => {
+      buffers.push(chunk);
+      bytes += chunk.length;
+      if (maxBytesNumber !== void 0 && bytes > maxBytesNumber) {
+        if ("closed" in stream && !stream.closed) {
+          stream.destroy();
+        }
+        resume(Effect.fail(onError(new Error("maxBytes exceeded"))));
+      }
+    });
+    return Effect.sync(() => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+    });
+  });
+};
+var toUint8Array = (readable, options) => Effect.map(toArrayBuffer(readable, options), (buffer) => new Uint8Array(buffer));
+var readableToPullUnsafe = (options) => {
+  const readable = options.readable;
+  const closeOnDone = options.closeOnDone ?? true;
+  const exit = options.exit ?? MutableRef.make(void 0);
+  const latch = options.latch ?? Latch.makeUnsafe(false);
+  function onReadable() {
+    latch.openUnsafe();
+  }
+  function onError(error) {
+    exit.current = Exit.fail(options.onError(error));
+    latch.openUnsafe();
+  }
+  function onEnd() {
+    exit.current = Exit.fail(Cause.Done());
+    latch.openUnsafe();
+  }
+  readable.on("readable", onReadable);
+  readable.once("error", onError);
+  readable.once("end", onEnd);
+  const pull = Effect.suspend(function loop() {
+    let item = options.readable.read(options.chunkSize);
+    if (item === null) {
+      if (exit.current) {
+        return exit.current;
+      }
+      if (readable.readableEnded) {
+        return Effect.fail(Cause.Done());
+      }
+      latch.closeUnsafe();
+      return Effect.flatMap(latch.await, loop);
+    }
+    const chunk = Arr.of(item);
+    while (true) {
+      item = options.readable.read(options.chunkSize);
+      if (item === null) break;
+      chunk.push(item);
+    }
+    return Effect.succeed(chunk);
+  });
+  return Effect.as(Scope.addFinalizer(options.scope, Effect.sync(() => {
+    readable.off("readable", onReadable);
+    readable.off("error", onError);
+    readable.off("end", onEnd);
+    if (closeOnDone && "closed" in options.readable && !options.readable.closed) {
+      options.readable.destroy();
+    }
+  })), pull);
+};
+var StreamAdapter = class extends Readable {
+  readLatch;
+  fiber = void 0;
+  constructor(context2, stream) {
+    super({});
+    this.readLatch = Latch.makeUnsafe(false);
+    this.fiber = Stream.runForEachArray(stream, (chunk) => this.readLatch.whenOpen(Effect.sync(() => {
+      this.readLatch.closeUnsafe();
+      for (let i = 0; i < chunk.length; i++) {
+        const item = chunk[i];
+        if (typeof item === "string") {
+          this.push(item, "utf8");
+        } else {
+          this.push(item);
+        }
+      }
+    }))).pipe(this.readLatch.whenOpen, Effect.provideContext(context2), Effect.runFork);
+    this.fiber.addObserver((exit) => {
+      this.fiber = void 0;
+      if (Exit.isSuccess(exit)) {
+        this.push(null);
+      } else {
+        this.destroy(Cause.squash(exit.cause));
+      }
+    });
+  }
+  _read(_size) {
+    this.readLatch.openUnsafe();
+  }
+  _destroy(error, callback2) {
+    if (!this.fiber) {
+      return callback2(error);
+    }
+    Effect.runFork(Fiber.interrupt(this.fiber)).addObserver((exit) => {
+      callback2(exit._tag === "Failure" ? Cause.squash(exit.cause) : error);
+    });
+  }
+};
+var defaultOnError = (error) => new Cause.UnknownError(error);
+var toMaxBytes = (maxBytes) => maxBytes === void 0 || maxBytes === Infinity ? void 0 : Number(ByteSize.fromInputUnsafe(maxBytes));
+
+export {
+  fromReadable,
+  fromReadableChannel,
+  fromDuplex,
+  pipeThroughDuplex,
+  pipeThroughSimple,
+  toReadable,
+  toReadableNever,
+  toString,
+  toArrayBuffer,
+  toUint8Array,
+  NodeStream_exports
+};

package/dist/vendor/chunk-TBMTA5LD.js

@@ -0,0 +1,14 @@
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.5_effect@4.0.5/node_modules/@effect/platform-node-shared/dist/internal/nodeChildProcessSpawner.js
+var buildSpawnOptions = (options, base, platform) => {
+  const detached = options.detached ?? platform !== "win32";
+  return {
+    ...base,
+    detached,
+    shell: options.shell,
+    windowsHide: options.windowsHide ?? !detached
+  };
+};
+
+export {
+  buildSpawnOptions
+};