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

package/dist/vendor/chunk-7JOAEKDV.js

@@ -0,0 +1,503 @@
+import {
+  handleErrnoException
+} from "./chunk-3SUO3TTE.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/NodeFileSystem.js
+var NodeFileSystem_exports = {};
+__export(NodeFileSystem_exports, {
+  layer: () => layer
+});
+import * as BI from "effect/BigInt";
+import * as ByteSize from "effect/ByteSize";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import { effectify } from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import { pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Error from "effect/PlatformError";
+import * as Queue from "effect/Queue";
+import * as Stream from "effect/Stream";
+import * as Crypto from "node:crypto";
+import * as NFS from "node:fs";
+import * as OS from "node:os";
+import * as Path from "node:path";
+var handleBadArgument = (method) => (err) => Error.badArgument({
+  module: "FileSystem",
+  method,
+  description: err.message ?? String(err)
+});
+var bigintToNumber = (value, field) => {
+  const number = Number(value);
+  if (!Number.isSafeInteger(number)) {
+    throw new RangeError(`${field} exceeds the safe integer range: ${value}`);
+  }
+  return number;
+};
+var bigintToNumberOption = (value) => Option.flatMap(Option.fromNullishOr(value), BI.toNumber);
+var toUint64 = (value) => BigInt.asUintN(64, value);
+var toUint64Option = (value) => Option.map(Option.fromNullishOr(value), toUint64);
+var positionToNumber = (position, method) => Effect.try({
+  try: () => bigintToNumber(position, "position"),
+  catch: handleBadArgument(method)
+});
+var access2 = /* @__PURE__ */ (() => {
+  const nodeAccess = /* @__PURE__ */ effectify(NFS.access, /* @__PURE__ */ handleErrnoException("FileSystem", "access"), /* @__PURE__ */ handleBadArgument("access"));
+  return (path, options) => {
+    let mode = NFS.constants.F_OK;
+    if (options?.readable) {
+      mode |= NFS.constants.R_OK;
+    }
+    if (options?.writable) {
+      mode |= NFS.constants.W_OK;
+    }
+    return nodeAccess(path, mode);
+  };
+})();
+var copy = /* @__PURE__ */ (() => {
+  const nodeCp = /* @__PURE__ */ effectify(NFS.cp, /* @__PURE__ */ handleErrnoException("FileSystem", "copy"), /* @__PURE__ */ handleBadArgument("copy"));
+  return (fromPath, toPath, options) => nodeCp(fromPath, toPath, {
+    force: options?.overwrite ?? false,
+    preserveTimestamps: options?.preserveTimestamps ?? false,
+    recursive: true
+  });
+})();
+var copyFile2 = /* @__PURE__ */ (() => {
+  const nodeCopyFile = /* @__PURE__ */ effectify(NFS.copyFile, /* @__PURE__ */ handleErrnoException("FileSystem", "copyFile"), /* @__PURE__ */ handleBadArgument("copyFile"));
+  return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);
+})();
+var chmod2 = /* @__PURE__ */ (() => {
+  const nodeChmod = /* @__PURE__ */ effectify(NFS.chmod, /* @__PURE__ */ handleErrnoException("FileSystem", "chmod"), /* @__PURE__ */ handleBadArgument("chmod"));
+  return (path, mode) => nodeChmod(path, mode);
+})();
+var chown2 = /* @__PURE__ */ (() => {
+  const nodeChown = /* @__PURE__ */ effectify(NFS.chown, /* @__PURE__ */ handleErrnoException("FileSystem", "chown"), /* @__PURE__ */ handleBadArgument("chown"));
+  return (path, uid, gid) => nodeChown(path, uid, gid);
+})();
+var glob2 = /* @__PURE__ */ (() => {
+  const nodeGlob = /* @__PURE__ */ effectify(NFS.glob, /* @__PURE__ */ handleErrnoException("FileSystem", "glob"), /* @__PURE__ */ handleBadArgument("glob"));
+  return (pattern, options) => nodeGlob(pattern, {
+    cwd: options?.root,
+    exclude: options?.exclude
+  });
+})();
+var link2 = /* @__PURE__ */ (() => {
+  const nodeLink = /* @__PURE__ */ effectify(NFS.link, /* @__PURE__ */ handleErrnoException("FileSystem", "link"), /* @__PURE__ */ handleBadArgument("link"));
+  return (existingPath, newPath) => nodeLink(existingPath, newPath);
+})();
+var makeDirectory = /* @__PURE__ */ (() => {
+  const nodeMkdir = /* @__PURE__ */ effectify(NFS.mkdir, /* @__PURE__ */ handleErrnoException("FileSystem", "makeDirectory"), /* @__PURE__ */ handleBadArgument("makeDirectory"));
+  return (path, options) => nodeMkdir(path, {
+    recursive: options?.recursive ?? false,
+    mode: options?.mode
+  });
+})();
+var makeTempDirectoryFactory = (method) => {
+  const nodeMkdtemp = effectify(NFS.mkdtemp, handleErrnoException("FileSystem", method), handleBadArgument(method));
+  return (options) => Effect.suspend(() => {
+    const prefix = options?.prefix ?? "";
+    const directory = typeof options?.directory === "string" ? Path.join(options.directory, ".") : OS.tmpdir();
+    return nodeMkdtemp(prefix ? Path.join(directory, prefix) : directory + "/");
+  });
+};
+var makeTempDirectory = /* @__PURE__ */ makeTempDirectoryFactory("makeTempDirectory");
+var removeFactory = (method) => {
+  const nodeRm = effectify(NFS.rm, handleErrnoException("FileSystem", method), handleBadArgument(method));
+  return (path, options) => nodeRm(path, {
+    recursive: options?.recursive ?? false,
+    force: options?.force ?? false
+  });
+};
+var remove = /* @__PURE__ */ removeFactory("remove");
+var makeTempDirectoryScoped = /* @__PURE__ */ (() => {
+  const makeDirectory2 = /* @__PURE__ */ makeTempDirectoryFactory("makeTempDirectoryScoped");
+  const removeDirectory = /* @__PURE__ */ removeFactory("makeTempDirectoryScoped");
+  return (options) => Effect.acquireRelease(makeDirectory2(options), (directory) => Effect.orDie(removeDirectory(directory, {
+    recursive: true
+  })));
+})();
+var openFlagBits = (flag) => {
+  const {
+    O_APPEND,
+    O_CREAT,
+    O_EXCL,
+    O_RDONLY,
+    O_RDWR,
+    O_TRUNC,
+    O_WRONLY
+  } = NFS.constants;
+  switch (flag) {
+    case "r":
+      return O_RDONLY;
+    case "r+":
+      return O_RDWR;
+    case "w":
+      return O_TRUNC | O_CREAT | O_WRONLY;
+    case "wx":
+      return O_TRUNC | O_CREAT | O_WRONLY | O_EXCL;
+    case "w+":
+      return O_TRUNC | O_CREAT | O_RDWR;
+    case "wx+":
+      return O_TRUNC | O_CREAT | O_RDWR | O_EXCL;
+    case "a":
+      return O_APPEND | O_CREAT | O_WRONLY;
+    case "ax":
+      return O_APPEND | O_CREAT | O_WRONLY | O_EXCL;
+    case "a+":
+      return O_APPEND | O_CREAT | O_RDWR;
+    case "ax+":
+      return O_APPEND | O_CREAT | O_RDWR | O_EXCL;
+  }
+};
+var noFollowFlags = (method, flag) => Effect.suspend(() => {
+  const {
+    O_NOFOLLOW
+  } = NFS.constants;
+  if (process.platform === "win32" || typeof O_NOFOLLOW !== "number" || O_NOFOLLOW === 0) {
+    return Effect.fail(Error.badArgument({
+      module: "FileSystem",
+      method,
+      description: "noFollow is not supported on this platform"
+    }));
+  }
+  return Effect.succeed(openFlagBits(flag) | O_NOFOLLOW);
+});
+var openFactory = (method) => {
+  const nodeOpen = effectify(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
+  const nodeClose = effectify(NFS.close, handleErrnoException("FileSystem", method), handleBadArgument(method));
+  return (path, options) => pipe(Effect.acquireRelease(options?.noFollow === true ? Effect.flatMap(noFollowFlags(method, options.flag ?? "r"), (flags) => nodeOpen(path, flags, options.mode)) : nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) => Effect.orDie(nodeClose(fd))), Effect.map((fd) => makeFile(fd, options?.flag?.startsWith("a") ?? false)));
+};
+var open2 = /* @__PURE__ */ openFactory("open");
+var negativePosition = (method) => Error.badArgument({
+  module: "FileSystem",
+  method,
+  description: "Cannot read before the start of the file"
+});
+var makeFile = /* @__PURE__ */ (() => {
+  const nodeReadFactory = (method) => effectify(NFS.read, handleErrnoException("FileSystem", method), handleBadArgument(method));
+  const nodeRead = /* @__PURE__ */ nodeReadFactory("read");
+  const nodeReadAlloc = /* @__PURE__ */ nodeReadFactory("readAlloc");
+  const nodeStat = /* @__PURE__ */ effectify(NFS.fstat, /* @__PURE__ */ handleErrnoException("FileSystem", "stat"), /* @__PURE__ */ handleBadArgument("stat"));
+  const nodeTruncate = /* @__PURE__ */ effectify(NFS.ftruncate, /* @__PURE__ */ handleErrnoException("FileSystem", "truncate"), /* @__PURE__ */ handleBadArgument("truncate"));
+  const nodeSync = /* @__PURE__ */ effectify(NFS.fsync, /* @__PURE__ */ handleErrnoException("FileSystem", "sync"), /* @__PURE__ */ handleBadArgument("sync"));
+  const nodeWriteFactory = (method) => effectify(NFS.write, handleErrnoException("FileSystem", method), handleBadArgument(method));
+  const nodeWrite = /* @__PURE__ */ nodeWriteFactory("write");
+  const nodeWriteAll = /* @__PURE__ */ nodeWriteFactory("writeAll");
+  class FileImpl {
+    [FileSystem.FileTypeId];
+    fd;
+    append;
+    position = /* @__PURE__ */ BigInt(0);
+    constructor(fd, append) {
+      this[FileSystem.FileTypeId] = FileSystem.FileTypeId;
+      this.fd = fd;
+      this.append = append;
+    }
+    get stat() {
+      return Effect.flatMap(nodeStat(this.fd, {
+        bigint: true
+      }), makeFileInfo);
+    }
+    get sync() {
+      return nodeSync(this.fd);
+    }
+    seek(offset, from) {
+      return Effect.suspend(() => {
+        const position = from === "start" ? offset : this.position + offset;
+        if (position < BigInt(0)) {
+          return Effect.fail(Error.badArgument({
+            module: "FileSystem",
+            method: "seek",
+            description: "Cannot seek before the start of the file"
+          }));
+        }
+        this.position = position;
+        return Effect.succeed(position);
+      });
+    }
+    read(buffer, options) {
+      return Effect.suspend(() => {
+        const explicit = options?.position;
+        if (explicit !== void 0) {
+          return explicit < BigInt(0) ? Effect.fail(negativePosition("read")) : nodeRead(this.fd, {
+            buffer,
+            position: explicit
+          });
+        }
+        const position = this.position;
+        return Effect.map(nodeRead(this.fd, {
+          buffer,
+          position
+        }), (bytesRead) => {
+          this.position = position + BigInt(bytesRead);
+          return bytesRead;
+        });
+      });
+    }
+    readAlloc(size, options) {
+      return Effect.suspend(() => {
+        try {
+          if (!Number.isInteger(size) || size < 0) {
+            throw new RangeError("size must be a non-negative integer");
+          }
+          const explicit = options?.position;
+          if (explicit !== void 0 && explicit < BigInt(0)) {
+            return Effect.fail(negativePosition("readAlloc"));
+          }
+          const buffer = Buffer.allocUnsafeSlow(size);
+          const position = explicit ?? this.position;
+          return Effect.map(nodeReadAlloc(this.fd, {
+            buffer,
+            position
+          }), (bytesRead) => {
+            if (bytesRead === 0) {
+              return Option.none();
+            }
+            if (explicit === void 0) {
+              this.position = position + BigInt(bytesRead);
+            }
+            if (bytesRead === size) {
+              return Option.some(buffer);
+            }
+            const dst = Buffer.allocUnsafeSlow(bytesRead);
+            buffer.copy(dst, 0, 0, bytesRead);
+            return Option.some(dst);
+          });
+        } catch (cause) {
+          return Effect.fail(handleBadArgument("readAlloc")(cause));
+        }
+      });
+    }
+    truncate(length) {
+      return Effect.map(nodeTruncate(this.fd, length || void 0), () => {
+        if (!this.append) {
+          const len = BigInt(length ?? 0);
+          if (this.position > len) {
+            this.position = len;
+          }
+        }
+      });
+    }
+    write(buffer) {
+      return Effect.suspend(() => {
+        const position = this.position;
+        return Effect.flatMap(this.append ? Effect.succeed(void 0) : positionToNumber(position, "write"), (nodePosition) => Effect.map(nodeWrite(this.fd, buffer, void 0, void 0, nodePosition), (bytesWritten) => {
+          if (!this.append) {
+            this.position = position + BigInt(bytesWritten);
+          }
+          return bytesWritten;
+        }));
+      });
+    }
+    writeAllChunk(buffer) {
+      return Effect.suspend(() => {
+        const position = this.position;
+        return Effect.flatMap(this.append ? Effect.succeed(void 0) : positionToNumber(position, "writeAll"), (nodePosition) => Effect.flatMap(nodeWriteAll(this.fd, buffer, void 0, void 0, nodePosition), (bytesWritten) => {
+          if (bytesWritten === 0) {
+            return Effect.fail(Error.systemError({
+              module: "FileSystem",
+              method: "writeAll",
+              _tag: "WriteZero",
+              pathOrDescriptor: this.fd,
+              description: "write returned 0 bytes written"
+            }));
+          }
+          if (!this.append) {
+            this.position = position + BigInt(bytesWritten);
+          }
+          return bytesWritten < buffer.length ? this.writeAllChunk(buffer.subarray(bytesWritten)) : Effect.void;
+        }));
+      });
+    }
+    writeAll(buffer) {
+      return buffer.length === 0 ? Effect.void : this.writeAllChunk(buffer);
+    }
+  }
+  return (fd, append) => new FileImpl(fd, append);
+})();
+var makeTempFileFactory = (method) => {
+  const makeDirectory2 = makeTempDirectoryFactory(method);
+  return Effect.fnUntraced(function* (options) {
+    const directory = yield* makeDirectory2(options);
+    const random = Crypto.randomBytes(6).toString("hex");
+    const name = Path.join(directory, options?.suffix ? `${random}${options.suffix}` : random);
+    yield* writeFile2(name, new Uint8Array(0));
+    return name;
+  });
+};
+var makeTempFile = /* @__PURE__ */ makeTempFileFactory("makeTempFile");
+var makeTempFileScoped = /* @__PURE__ */ (() => {
+  const makeFile2 = /* @__PURE__ */ makeTempFileFactory("makeTempFileScoped");
+  const removeDirectory = /* @__PURE__ */ removeFactory("makeTempFileScoped");
+  return (options) => Effect.acquireRelease(makeFile2(options), (file) => Effect.orDie(removeDirectory(Path.dirname(file), {
+    recursive: true
+  })));
+})();
+var readDirectory = (path, options) => Effect.tryPromise({
+  try: () => NFS.promises.readdir(path, options),
+  catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path])
+});
+var readFile2 = (path) => Effect.callback((resume, signal) => {
+  try {
+    NFS.readFile(path, {
+      signal
+    }, (err, data) => {
+      if (err) {
+        resume(Effect.fail(handleErrnoException("FileSystem", "readFile")(err, [path])));
+      } else {
+        resume(Effect.succeed(data));
+      }
+    });
+  } catch (err) {
+    resume(Effect.fail(handleBadArgument("readFile")(err)));
+  }
+});
+var readLink = /* @__PURE__ */ (() => {
+  const nodeReadLink = /* @__PURE__ */ effectify(NFS.readlink, /* @__PURE__ */ handleErrnoException("FileSystem", "readLink"), /* @__PURE__ */ handleBadArgument("readLink"));
+  return (path) => nodeReadLink(path);
+})();
+var realPath = /* @__PURE__ */ (() => {
+  const nodeRealPath = /* @__PURE__ */ effectify(NFS.realpath, /* @__PURE__ */ handleErrnoException("FileSystem", "realPath"), /* @__PURE__ */ handleBadArgument("realPath"));
+  return (path) => nodeRealPath(path);
+})();
+var rename2 = /* @__PURE__ */ (() => {
+  const nodeRename = /* @__PURE__ */ effectify(NFS.rename, /* @__PURE__ */ handleErrnoException("FileSystem", "rename"), /* @__PURE__ */ handleBadArgument("rename"));
+  return (oldPath, newPath) => nodeRename(oldPath, newPath);
+})();
+var makeFileInfo = (stat3) => Effect.try({
+  try: () => ({
+    type: stat3.isFile() ? "File" : stat3.isDirectory() ? "Directory" : stat3.isSymbolicLink() ? "SymbolicLink" : stat3.isBlockDevice() ? "BlockDevice" : stat3.isCharacterDevice() ? "CharacterDevice" : stat3.isFIFO() ? "FIFO" : stat3.isSocket() ? "Socket" : "Unknown",
+    mtime: Option.fromNullishOr(stat3.mtime),
+    atime: Option.fromNullishOr(stat3.atime),
+    birthtime: Option.fromNullishOr(stat3.birthtime),
+    dev: toUint64(stat3.dev),
+    rdev: toUint64Option(stat3.rdev),
+    ino: toUint64Option(stat3.ino),
+    mode: bigintToNumber(stat3.mode, "mode"),
+    nlink: toUint64Option(stat3.nlink),
+    uid: bigintToNumberOption(stat3.uid),
+    gid: bigintToNumberOption(stat3.gid),
+    size: ByteSize.bytes(stat3.size),
+    blksize: stat3.blksize !== void 0 ? Option.some(ByteSize.bytes(stat3.blksize)) : Option.none(),
+    blocks: Option.fromNullishOr(stat3.blocks)
+  }),
+  catch: handleBadArgument("stat")
+});
+var stat2 = /* @__PURE__ */ (() => {
+  const nodeStat = /* @__PURE__ */ effectify(NFS.stat, /* @__PURE__ */ handleErrnoException("FileSystem", "stat"), /* @__PURE__ */ handleBadArgument("stat"));
+  return (path) => Effect.flatMap(nodeStat(path, {
+    bigint: true
+  }), makeFileInfo);
+})();
+var symlink2 = /* @__PURE__ */ (() => {
+  const nodeSymlink = /* @__PURE__ */ effectify(NFS.symlink, /* @__PURE__ */ handleErrnoException("FileSystem", "symlink"), /* @__PURE__ */ handleBadArgument("symlink"));
+  return (target, path) => nodeSymlink(target, path);
+})();
+var truncate2 = /* @__PURE__ */ (() => {
+  const nodeTruncate = /* @__PURE__ */ effectify(NFS.truncate, /* @__PURE__ */ handleErrnoException("FileSystem", "truncate"), /* @__PURE__ */ handleBadArgument("truncate"));
+  return (path, length) => nodeTruncate(path, length);
+})();
+var utimes2 = /* @__PURE__ */ (() => {
+  const nodeUtimes = /* @__PURE__ */ effectify(NFS.utimes, /* @__PURE__ */ handleErrnoException("FileSystem", "utime"), /* @__PURE__ */ handleBadArgument("utime"));
+  return (path, atime, mtime) => nodeUtimes(path, atime, mtime);
+})();
+var watchNode = (path, info, options) => Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+  const directory = info.type === "Directory" ? path : Path.dirname(path);
+  const watcher = NFS.watch(path, {
+    recursive: options?.recursive ?? false
+  }, (event, path2) => {
+    if (!path2) return;
+    switch (event) {
+      case "rename": {
+        Effect.runFork(Effect.matchEffect(stat2(Path.resolve(directory, path2)), {
+          onSuccess: (_) => Queue.offer(queue, {
+            _tag: "Create",
+            path: path2
+          }),
+          onFailure: (_) => Queue.offer(queue, {
+            _tag: "Remove",
+            path: path2
+          })
+        }));
+        return;
+      }
+      case "change": {
+        Queue.offerUnsafe(queue, {
+          _tag: "Update",
+          path: path2
+        });
+        return;
+      }
+    }
+  });
+  watcher.on("error", (error) => {
+    Queue.failCauseUnsafe(queue, Cause.fail(Error.systemError({
+      module: "FileSystem",
+      _tag: "Unknown",
+      method: "watch",
+      pathOrDescriptor: path,
+      cause: error
+    })));
+  });
+  watcher.on("close", () => {
+    Queue.endUnsafe(queue);
+  });
+  return watcher;
+}), (watcher) => Effect.sync(() => watcher.close())).pipe(Effect.tap(() => Effect.sync(() => options?.onReady?.()))));
+var watch2 = (backend, path, options) => Effect.all([stat2(path), Effect.serviceOption(FileSystem.WatchBackend)]).pipe(Effect.map(([stat3, callerBackend]) => Option.orElse(callerBackend, () => backend).pipe(Option.flatMap((_) => _.register(path, stat3, options)), Option.getOrElse(() => watchNode(path, stat3, options)))), Stream.unwrap);
+var writeFile2 = (path, data, options) => Effect.callback((resume, signal) => {
+  try {
+    NFS.writeFile(path, data, {
+      signal,
+      flag: options?.flag,
+      mode: options?.mode
+    }, (err) => {
+      if (err) {
+        resume(Effect.fail(handleErrnoException("FileSystem", "writeFile")(err, [path])));
+      } else {
+        resume(Effect.void);
+      }
+    });
+  } catch (err) {
+    resume(Effect.fail(handleBadArgument("writeFile")(err)));
+  }
+});
+var makeFileSystem = /* @__PURE__ */ Effect.map(/* @__PURE__ */ Effect.serviceOption(FileSystem.WatchBackend), (backend) => FileSystem.make({
+  access: access2,
+  chmod: chmod2,
+  chown: chown2,
+  copy,
+  copyFile: copyFile2,
+  glob: glob2,
+  link: link2,
+  makeDirectory,
+  makeTempDirectory,
+  makeTempDirectoryScoped,
+  makeTempFile,
+  makeTempFileScoped,
+  open: open2,
+  readDirectory,
+  readFile: readFile2,
+  readLink,
+  realPath,
+  remove,
+  rename: rename2,
+  stat: stat2,
+  symlink: symlink2,
+  truncate: truncate2,
+  utimes: utimes2,
+  watch(path, options) {
+    return watch2(backend, path, options);
+  },
+  writeFile: writeFile2
+}));
+var layer = /* @__PURE__ */ Layer.effect(FileSystem.FileSystem)(makeFileSystem);
+
+export {
+  layer,
+  NodeFileSystem_exports
+};

package/dist/vendor/chunk-7VJC3PHX.js

@@ -0,0 +1,63 @@
+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/BunWorker.js
+var BunWorker_exports = {};
+__export(BunWorker_exports, {
+  layer: () => layer,
+  layerPlatform: () => layerPlatform
+});
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as Worker from "effect/workers/Worker";
+import { WorkerError, WorkerUnknownError } from "effect/workers/WorkerError";
+var layer = (spawn) => Layer.merge(layerPlatform, Layer.succeed(Worker.Spawner)(spawn));
+var layerPlatform = /* @__PURE__ */ Layer.succeed(Worker.WorkerPlatform)(/* @__PURE__ */ Worker.makePlatform()({
+  setup({
+    scope,
+    worker
+  }) {
+    const closeDeferred = Deferred.makeUnsafe();
+    worker.addEventListener("close", () => {
+      Deferred.doneUnsafe(closeDeferred, Exit.void);
+    });
+    return Effect.as(Scope.addFinalizer(scope, Effect.suspend(() => {
+      worker.postMessage([1]);
+      return Deferred.await(closeDeferred);
+    }).pipe(Effect.interruptible, Effect.timeout(5e3), Effect.catchCause(() => Effect.sync(() => worker.terminate())))), worker);
+  },
+  listen({
+    deferred,
+    emit,
+    port,
+    scope
+  }) {
+    function onMessage(event) {
+      emit(event.data);
+    }
+    function onError(event) {
+      Deferred.doneUnsafe(deferred, new WorkerError({
+        reason: new WorkerUnknownError({
+          message: "An error event was emitted",
+          cause: event.error ?? event.message
+        })
+      }));
+    }
+    port.addEventListener("message", onMessage);
+    port.addEventListener("error", onError);
+    return Scope.addFinalizer(scope, Effect.sync(() => {
+      port.removeEventListener("message", onMessage);
+      port.removeEventListener("error", onError);
+    }));
+  }
+}));
+
+export {
+  layer,
+  layerPlatform,
+  BunWorker_exports
+};

package/dist/vendor/chunk-7ZKNPDTP.js

@@ -0,0 +1,26 @@
+import {
+  layer,
+  layerPosix,
+  layerWin32
+} from "./chunk-JTST2Z7N.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/BunPath.js
+var BunPath_exports = {};
+__export(BunPath_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,
+  BunPath_exports
+};

package/dist/vendor/chunk-ABPRHPJP.js

@@ -0,0 +1,15 @@
+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/BunHttpServerRequest.js
+var BunHttpServerRequest_exports = {};
+__export(BunHttpServerRequest_exports, {
+  toBunServerRequest: () => toBunServerRequest
+});
+var toBunServerRequest = (self) => self.source;
+
+export {
+  toBunServerRequest,
+  BunHttpServerRequest_exports
+};