@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/vendor/chunk-BKTBUBQY.js

@@ -0,0 +1,437 @@
+import {
+  handleErrnoException
+} from "./chunk-42QKY6T6.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/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 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 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(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 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) {
+      return Effect.suspend(() => {
+        const position = this.position;
+        return Effect.map(nodeRead(this.fd, {
+          buffer,
+          position
+        }), (bytesRead) => {
+          this.position = position + BigInt(bytesRead);
+          return bytesRead;
+        });
+      });
+    }
+    readAlloc(size) {
+      return Effect.suspend(() => {
+        try {
+          if (!Number.isInteger(size) || size < 0) {
+            throw new RangeError("size must be a non-negative integer");
+          }
+          const buffer = Buffer.allocUnsafeSlow(size);
+          const position = this.position;
+          return Effect.map(nodeReadAlloc(this.fd, {
+            buffer,
+            position
+          }), (bytesRead) => {
+            if (bytesRead === 0) {
+              return Option.none();
+            }
+            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: bigintToNumber(stat3.dev, "dev"),
+    rdev: bigintToNumberOption(stat3.rdev),
+    ino: bigintToNumberOption(stat3.ino),
+    mode: bigintToNumber(stat3.mode, "mode"),
+    nlink: bigintToNumberOption(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: bigintToNumberOption(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())));
+var watch2 = (backend, path, options) => stat2(path).pipe(Effect.map((stat3) => 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-DS7GF46S.js

@@ -0,0 +1,34 @@
+import {
+  fromDuplex,
+  fromReadable,
+  fromReadableChannel,
+  pipeThroughDuplex,
+  pipeThroughSimple,
+  toArrayBuffer,
+  toReadable,
+  toReadableNever,
+  toString,
+  toUint8Array
+} from "./chunk-XH4U3JSV.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/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-DVOAHXPG.js

@@ -0,0 +1,104 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeWorkerRunner.js
+var NodeWorkerRunner_exports = {};
+__export(NodeWorkerRunner_exports, {
+  layer: () => layer
+});
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/unstable/workers/WorkerError";
+import * as WorkerRunner from "effect/unstable/workers/WorkerRunner";
+import * as WorkerThreads from "node:worker_threads";
+var layer = /* @__PURE__ */ Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
+  start() {
+    return Effect.gen(function* () {
+      if (!WorkerThreads.parentPort && !process.send) {
+        return yield* new WorkerError({
+          reason: new WorkerSpawnError({
+            message: "not in a worker"
+          })
+        });
+      }
+      const sendRaw = WorkerThreads.parentPort ? (_portId, message, transfers) => WorkerThreads.parentPort.postMessage(message, transfers) : (_portId, message, _transfers) => process.send(message);
+      const sendUnsafe = (_portId, message, transfers) => sendRaw(_portId, [1, message], transfers);
+      const send = (_portId, message, transfers) => Effect.sync(() => sendUnsafe(_portId, message, transfers));
+      const run = (handler) => Effect.scopedWith(Effect.fnUntraced(function* (scope) {
+        const closeLatch = Deferred.makeUnsafe();
+        const trackFiber = Fiber.runIn(scope);
+        const services = yield* Effect.context();
+        const runFork = Effect.runForkWith(services);
+        const onExit = (exit) => {
+          if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
+            runFork(Effect.logError("unhandled error in worker", exit.cause));
+          }
+        };
+        const port = WorkerThreads.parentPort ?? process;
+        function onMessage(message) {
+          if (message[0] === 0) {
+            const result = handler(0, message[1]);
+            if (Effect.isEffect(result)) {
+              const fiber = runFork(result);
+              fiber.addObserver(onExit);
+              trackFiber(fiber);
+            }
+          } else {
+            if (WorkerThreads.parentPort) {
+              WorkerThreads.parentPort.close();
+            } else {
+              process.channel?.unref();
+            }
+            Deferred.doneUnsafe(closeLatch, Exit.void);
+          }
+        }
+        port.on("message", onMessage);
+        function onMessageError(cause) {
+          Deferred.doneUnsafe(closeLatch, new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "received messageerror event",
+              cause
+            })
+          }));
+        }
+        function onError(cause) {
+          Deferred.doneUnsafe(closeLatch, new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "received error event",
+              cause
+            })
+          }));
+        }
+        if (WorkerThreads.parentPort) {
+          WorkerThreads.parentPort.on("messageerror", onMessageError);
+          WorkerThreads.parentPort.on("error", onError);
+        }
+        yield* Scope.addFinalizer(scope, Effect.sync(() => {
+          port.off("message", onMessage);
+          if (WorkerThreads.parentPort) {
+            WorkerThreads.parentPort.off("messageerror", onMessageError);
+            WorkerThreads.parentPort.off("error", onError);
+          }
+        }));
+        sendRaw(0, [0]);
+        return yield* Deferred.await(closeLatch);
+      }));
+      return {
+        run,
+        send,
+        sendUnsafe
+      };
+    });
+  }
+});
+
+export {
+  layer,
+  NodeWorkerRunner_exports
+};