priiisk 0.1.1

package/dist/chunk-F77DHFYU.js

@@ -0,0 +1,988 @@
+import { createRequire as __priiiskCreateRequire } from "node:module";
+const require = __priiiskCreateRequire(import.meta.url);
+import {
+  BadArgument,
+  CommandExecutor,
+  ExitCode,
+  FileDescriptor,
+  FileSystem,
+  FileTypeId,
+  Path,
+  PlatformWorker,
+  ProcessId,
+  ProcessTypeId,
+  Size,
+  SystemError,
+  Terminal,
+  TypeId,
+  WatchBackend,
+  WatchEventCreate,
+  WatchEventRemove,
+  WatchEventUpdate,
+  WorkerError,
+  effectify,
+  flatten,
+  layerManager,
+  make as make4,
+  makeExecutor,
+  makePlatform,
+  makeRunMain,
+  stdin
+} from "./chunk-RJO6Z3SQ.js";
+import {
+  BaseProto,
+  __export,
+  _await2 as _await,
+  _void,
+  acquireRelease,
+  addFinalizer,
+  addFinalizer2,
+  as,
+  asVoid2 as asVoid,
+  async,
+  asyncScoped,
+  catchAllCause,
+  complete,
+  constUndefined,
+  constVoid,
+  drain,
+  effect,
+  embedInput,
+  ensuring,
+  ensuring3 as ensuring2,
+  fail,
+  fail4 as fail2,
+  failCause2 as failCause,
+  flatMap,
+  flatMap3 as flatMap2,
+  flatMap5 as flatMap3,
+  fnUntraced,
+  forkDaemon,
+  fromChannel,
+  fromChannel2,
+  fromEffect,
+  fromNullable,
+  gen,
+  get5 as get,
+  getOrElse,
+  identity,
+  ignore,
+  interruptible,
+  isDone,
+  make10 as make3,
+  make13 as make5,
+  make4 as make,
+  make9 as make2,
+  map2 as map,
+  map7 as map2,
+  match,
+  matchEffect,
+  mergeAll,
+  negate,
+  none,
+  orDie,
+  orElse2 as orElse,
+  pipe,
+  provide2 as provide,
+  provideMerge,
+  run,
+  scoped,
+  scoped2,
+  serviceOption,
+  some,
+  succeed3 as succeed,
+  succeed4 as succeed2,
+  suspend,
+  suspend3 as suspend2,
+  sync,
+  tap,
+  timeout,
+  transduce,
+  tryPromise,
+  try_,
+  uninterruptible,
+  unsafeDone,
+  unsafeFromArray,
+  unsafeMakeLatch,
+  unsafeMakeSemaphore,
+  unwrap,
+  unwrapScoped,
+  void_,
+  void_2,
+  write,
+  zip,
+  zipRight
+} from "./chunk-KFSFN6L5.js";
+
+// node_modules/.pnpm/@effect+platform-node@0.107.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effect@3.2_9535e05eb804fa0fb275ce283b448483/node_modules/@effect/platform-node/dist/esm/NodeContext.js
+var NodeContext_exports = {};
+__export(NodeContext_exports, {
+  layer: () => layer10
+});
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/internal/commandExecutor.js
+import * as ChildProcess from "node:child_process";
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/internal/error.js
+var handleErrnoException = (module, method) => (err, [path]) => {
+  let reason = "Unknown";
+  switch (err.code) {
+    case "ENOENT":
+      reason = "NotFound";
+      break;
+    case "EACCES":
+      reason = "PermissionDenied";
+      break;
+    case "EEXIST":
+      reason = "AlreadyExists";
+      break;
+    case "EISDIR":
+      reason = "BadResource";
+      break;
+    case "ENOTDIR":
+      reason = "BadResource";
+      break;
+    case "EBUSY":
+      reason = "Busy";
+      break;
+    case "ELOOP":
+      reason = "BadResource";
+      break;
+  }
+  return new SystemError({
+    reason,
+    module,
+    method,
+    pathOrDescriptor: path,
+    syscall: err.syscall,
+    description: err.message,
+    cause: err
+  });
+};
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/internal/stream.js
+import { Readable } from "node:stream";
+var fromReadable = (evaluate, onError, options) => fromChannel(fromReadableChannel(evaluate, onError, options));
+var fromReadableChannel = (evaluate, onError, options) => suspend2(() => unsafeReadableRead(evaluate(), onError, make(void 0), options));
+var writeInput = (writable, onFailure, {
+  encoding,
+  endOnDone = true
+} = {}, onDone = _void) => {
+  const write3 = writeEffect(writable, encoding);
+  const close2 = endOnDone ? async((resume) => {
+    if ("closed" in writable && writable.closed) {
+      resume(_void);
+    } else {
+      writable.once("finish", () => resume(_void));
+      writable.end();
+    }
+  }) : _void;
+  return {
+    awaitRead: () => _void,
+    emit: write3,
+    error: (cause) => zipRight(close2, onFailure(cause)),
+    done: (_) => zipRight(close2, onDone)
+  };
+};
+var writeEffect = (writable, encoding) => (chunk) => chunk.length === 0 ? _void : async((resume) => {
+  const iterator = chunk[Symbol.iterator]();
+  let next = iterator.next();
+  function loop() {
+    const item = next;
+    next = iterator.next();
+    const success = writable.write(item.value, encoding);
+    if (next.done) {
+      resume(_void);
+    } else if (success) {
+      loop();
+    } else {
+      writable.once("drain", loop);
+    }
+  }
+  loop();
+});
+var unsafeReadableRead = (readable, onError, exit, options) => {
+  if (!readable.readable) {
+    return void_2;
+  }
+  const latch = unsafeMakeLatch(false);
+  function onReadable() {
+    latch.unsafeOpen();
+  }
+  function onErr(err) {
+    exit.current = fail(onError(err));
+    latch.unsafeOpen();
+  }
+  function onEnd() {
+    exit.current = void_;
+    latch.unsafeOpen();
+  }
+  readable.on("readable", onReadable);
+  readable.on("error", onErr);
+  readable.on("end", onEnd);
+  const chunkSize = options?.chunkSize ? Number(options.chunkSize) : void 0;
+  const read2 = suspend2(function loop() {
+    let item = readable.read(chunkSize);
+    if (item === null) {
+      if (exit.current) {
+        return fromEffect(exit.current);
+      }
+      latch.unsafeClose();
+      return flatMap3(latch.await, loop);
+    }
+    const arr = [item];
+    while (true) {
+      item = readable.read(chunkSize);
+      if (item === null) {
+        return flatMap3(write(unsafeFromArray(arr)), loop);
+      }
+      arr.push(item);
+    }
+  });
+  return ensuring2(read2, sync(() => {
+    readable.off("readable", onReadable);
+    readable.off("error", onErr);
+    readable.off("end", onEnd);
+    if (options?.closeOnDone !== false && "closed" in readable && !readable.closed) {
+      readable.destroy();
+    }
+  }));
+};
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/internal/sink.js
+var fromWritable = (evaluate, onError, options) => fromChannel2(fromWritableChannel(evaluate, onError, options));
+var fromWritableChannel = (writable, onError, options) => flatMap3(zip(sync(() => writable()), make2()), ([writable2, deferred]) => embedInput(writableOutput(writable2, deferred, onError), writeInput(writable2, (cause) => failCause(deferred, cause), options, complete(deferred, _void))));
+var writableOutput = (writable, deferred, onError) => suspend(() => {
+  function handleError(err) {
+    unsafeDone(deferred, fail2(onError(err)));
+  }
+  writable.on("error", handleError);
+  return ensuring(_await(deferred), sync(() => {
+    writable.removeListener("error", handleError);
+  }));
+});
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/internal/commandExecutor.js
+var inputToStdioOption = (stdin2) => typeof stdin2 === "string" ? stdin2 : "pipe";
+var outputToStdioOption = (output) => typeof output === "string" ? output : "pipe";
+var toError = (err) => err instanceof globalThis.Error ? err : new globalThis.Error(String(err));
+var toPlatformError = (method, error, command) => {
+  const flattened = flatten(command).reduce((acc, curr) => {
+    const command2 = `${curr.command} ${curr.args.join(" ")}`;
+    return acc.length === 0 ? command2 : `${acc} | ${command2}`;
+  }, "");
+  return handleErrnoException("Command", method)(error, [flattened]);
+};
+var ProcessProto = {
+  [ProcessTypeId]: ProcessTypeId,
+  ...BaseProto,
+  toJSON() {
+    return {
+      _id: "@effect/platform/CommandExecutor/Process",
+      pid: this.pid
+    };
+  }
+};
+var runCommand = (fileSystem) => (command) => {
+  switch (command._tag) {
+    case "StandardCommand": {
+      const spawn2 = flatMap2(make2(), (exitCode) => async((resume) => {
+        const handle = ChildProcess.spawn(command.command, command.args, {
+          stdio: [inputToStdioOption(command.stdin), outputToStdioOption(command.stdout), outputToStdioOption(command.stderr)],
+          cwd: getOrElse(command.cwd, constUndefined),
+          shell: command.shell,
+          env: {
+            ...process.env,
+            ...Object.fromEntries(command.env)
+          },
+          detached: process.platform !== "win32"
+        });
+        handle.on("error", (err) => {
+          resume(fail2(toPlatformError("spawn", err, command)));
+        });
+        handle.on("exit", (...args) => {
+          unsafeDone(exitCode, succeed(args));
+        });
+        handle.on("spawn", () => {
+          resume(succeed([handle, exitCode]));
+        });
+        return sync(() => {
+          handle.kill("SIGTERM");
+        });
+      }));
+      const killProcessGroup = process.platform === "win32" ? (handle, _) => async((resume) => {
+        ChildProcess.exec(`taskkill /pid ${handle.pid} /T /F`, (error) => {
+          if (error) {
+            resume(fail2(toPlatformError("kill", toError(error), command)));
+          } else {
+            resume(_void);
+          }
+        });
+      }) : (handle, signal) => try_({
+        try: () => process.kill(-handle.pid, signal),
+        catch: (error) => toPlatformError("kill", toError(error), command)
+      });
+      const killProcess = (handle, signal) => suspend(() => handle.kill(signal) ? _void : fail2(toPlatformError("kill", new globalThis.Error("Failed to kill process"), command)));
+      return pipe(
+        // Validate that the directory is accessible
+        match(command.cwd, {
+          onNone: () => _void,
+          onSome: (dir) => fileSystem.access(dir)
+        }),
+        zipRight(acquireRelease(spawn2, ([handle, exitCode]) => flatMap2(isDone(exitCode), (done) => {
+          if (!done) {
+            return killProcessGroup(handle, "SIGTERM").pipe(orElse(() => killProcess(handle, "SIGTERM")), zipRight(_await(exitCode)), ignore);
+          }
+          return flatMap2(_await(exitCode), ([code]) => {
+            if (code !== 0 && code !== null) {
+              return killProcessGroup(handle, "SIGTERM").pipe(ignore);
+            }
+            return _void;
+          });
+        }))),
+        map2(([handle, exitCodeDeferred]) => {
+          let stdin2 = drain;
+          if (handle.stdin !== null) {
+            stdin2 = fromWritable(() => handle.stdin, (err) => toPlatformError("toWritable", toError(err), command));
+          }
+          const exitCode = flatMap2(_await(exitCodeDeferred), ([code, signal]) => {
+            if (code !== null) {
+              return succeed(ExitCode(code));
+            }
+            return fail2(toPlatformError("exitCode", new globalThis.Error(`Process interrupted due to receipt of signal: ${signal}`), command));
+          });
+          const isRunning = negate(isDone(exitCodeDeferred));
+          const kill = (signal = "SIGTERM") => killProcessGroup(handle, signal).pipe(orElse(() => killProcess(handle, signal)), zipRight(asVoid(_await(exitCodeDeferred))));
+          const pid = ProcessId(handle.pid);
+          const stderr = fromReadable(() => handle.stderr, (err) => toPlatformError("fromReadable(stderr)", toError(err), command));
+          let stdout = fromReadable(() => handle.stdout, (err) => toPlatformError("fromReadable(stdout)", toError(err), command));
+          if (typeof command.stdout !== "string") {
+            stdout = transduce(stdout, command.stdout);
+          }
+          return Object.assign(Object.create(ProcessProto), {
+            pid,
+            exitCode,
+            isRunning,
+            kill,
+            stdin: stdin2,
+            stderr,
+            stdout
+          });
+        }),
+        typeof command.stdin === "string" ? identity : tap((process2) => forkDaemon(run(command.stdin, process2.stdin)))
+      );
+    }
+    case "PipedCommand": {
+      const flattened = flatten(command);
+      if (flattened.length === 1) {
+        return pipe(flattened[0], runCommand(fileSystem));
+      }
+      const head = flattened[0];
+      const tail = flattened.slice(1);
+      const initial = tail.slice(0, tail.length - 1);
+      const last = tail[tail.length - 1];
+      const stream = initial.reduce((stdin2, command2) => pipe(stdin(command2, stdin2), runCommand(fileSystem), map2((process2) => process2.stdout), unwrapScoped), pipe(runCommand(fileSystem)(head), map2((process2) => process2.stdout), unwrapScoped));
+      return pipe(stdin(last, stream), runCommand(fileSystem));
+    }
+  }
+};
+var layer = /* @__PURE__ */ effect(CommandExecutor, /* @__PURE__ */ pipe(FileSystem, /* @__PURE__ */ map2((fileSystem) => makeExecutor(runCommand(fileSystem)))));
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/NodeCommandExecutor.js
+var layer2 = layer;
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/internal/fileSystem.js
+import * as Crypto from "node:crypto";
+import * as NFS from "node:fs";
+import * as OS from "node:os";
+import * as Path2 from "node:path";
+var handleBadArgument = (method) => (cause) => new BadArgument({
+  module: "FileSystem",
+  method,
+  cause
+});
+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 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) => suspend(() => {
+    const prefix = options?.prefix ?? "";
+    const directory = typeof options?.directory === "string" ? Path2.join(options.directory, ".") : OS.tmpdir();
+    return nodeMkdtemp(prefix ? Path2.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) => acquireRelease(makeDirectory2(options), (directory) => 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(acquireRelease(nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) => orDie(nodeClose(fd))), map2((fd) => makeFile(FileDescriptor(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 {
+    fd;
+    append;
+    [FileTypeId];
+    semaphore = /* @__PURE__ */ unsafeMakeSemaphore(1);
+    position = 0n;
+    constructor(fd, append) {
+      this.fd = fd;
+      this.append = append;
+      this[FileTypeId] = FileTypeId;
+    }
+    get stat() {
+      return map2(nodeStat(this.fd), makeFileInfo);
+    }
+    get sync() {
+      return nodeSync(this.fd);
+    }
+    seek(offset, from) {
+      const offsetSize = Size(offset);
+      return this.semaphore.withPermits(1)(sync(() => {
+        if (from === "start") {
+          this.position = offsetSize;
+        } else if (from === "current") {
+          this.position = this.position + offsetSize;
+        }
+        return this.position;
+      }));
+    }
+    read(buffer) {
+      return this.semaphore.withPermits(1)(map2(suspend(() => nodeRead(this.fd, {
+        buffer,
+        position: this.position
+      })), (bytesRead) => {
+        const sizeRead = Size(bytesRead);
+        this.position = this.position + sizeRead;
+        return sizeRead;
+      }));
+    }
+    readAlloc(size) {
+      const sizeNumber = Number(size);
+      return this.semaphore.withPermits(1)(flatMap2(sync(() => Buffer.allocUnsafeSlow(sizeNumber)), (buffer) => map2(nodeReadAlloc(this.fd, {
+        buffer,
+        position: this.position
+      }), (bytesRead) => {
+        if (bytesRead === 0) {
+          return none();
+        }
+        this.position = this.position + BigInt(bytesRead);
+        if (bytesRead === sizeNumber) {
+          return some(buffer);
+        }
+        const dst = Buffer.allocUnsafeSlow(bytesRead);
+        buffer.copy(dst, 0, 0, bytesRead);
+        return some(dst);
+      })));
+    }
+    truncate(length) {
+      return this.semaphore.withPermits(1)(map2(nodeTruncate(this.fd, length ? Number(length) : void 0), () => {
+        if (!this.append) {
+          const len = BigInt(length ?? 0);
+          if (this.position > len) {
+            this.position = len;
+          }
+        }
+      }));
+    }
+    write(buffer) {
+      return this.semaphore.withPermits(1)(map2(suspend(() => nodeWrite(this.fd, buffer, void 0, void 0, this.append ? void 0 : Number(this.position))), (bytesWritten) => {
+        const sizeWritten = Size(bytesWritten);
+        if (!this.append) {
+          this.position = this.position + sizeWritten;
+        }
+        return sizeWritten;
+      }));
+    }
+    writeAllChunk(buffer) {
+      return flatMap2(suspend(() => nodeWriteAll(this.fd, buffer, void 0, void 0, this.append ? void 0 : Number(this.position))), (bytesWritten) => {
+        if (bytesWritten === 0) {
+          return fail2(new SystemError({
+            module: "FileSystem",
+            method: "writeAll",
+            reason: "WriteZero",
+            pathOrDescriptor: this.fd,
+            description: "write returned 0 bytes written"
+          }));
+        }
+        if (!this.append) {
+          this.position = this.position + BigInt(bytesWritten);
+        }
+        return bytesWritten < buffer.length ? this.writeAllChunk(buffer.subarray(bytesWritten)) : _void;
+      });
+    }
+    writeAll(buffer) {
+      return this.semaphore.withPermits(1)(this.writeAllChunk(buffer));
+    }
+  }
+  return (fd, append) => new FileImpl(fd, append);
+})();
+var makeTempFileFactory = (method) => {
+  const makeDirectory2 = makeTempDirectoryFactory(method);
+  const open3 = openFactory(method);
+  const randomHexString = (bytes) => sync(() => Crypto.randomBytes(bytes).toString("hex"));
+  return (options) => pipe(zip(makeDirectory2(options), randomHexString(6)), map2(([directory, random]) => Path2.join(directory, random + (options?.suffix ?? ""))), tap((path) => scoped(open3(path, {
+    flag: "w+"
+  }))));
+};
+var makeTempFile = /* @__PURE__ */ makeTempFileFactory("makeTempFile");
+var makeTempFileScoped = /* @__PURE__ */ (() => {
+  const makeFile2 = /* @__PURE__ */ makeTempFileFactory("makeTempFileScoped");
+  const removeDirectory = /* @__PURE__ */ removeFactory("makeTempFileScoped");
+  return (options) => acquireRelease(makeFile2(options), (file) => orDie(removeDirectory(Path2.dirname(file), {
+    recursive: true
+  })));
+})();
+var readDirectory = (path, options) => tryPromise({
+  try: () => NFS.promises.readdir(path, options),
+  catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path])
+});
+var readFile2 = (path) => async((resume, signal) => {
+  try {
+    NFS.readFile(path, {
+      signal
+    }, (err, data) => {
+      if (err) {
+        resume(fail2(handleErrnoException("FileSystem", "readFile")(err, [path])));
+      } else {
+        resume(succeed(data));
+      }
+    });
+  } catch (err) {
+    resume(fail2(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) => ({
+  type: stat3.isFile() ? "File" : stat3.isDirectory() ? "Directory" : stat3.isSymbolicLink() ? "SymbolicLink" : stat3.isBlockDevice() ? "BlockDevice" : stat3.isCharacterDevice() ? "CharacterDevice" : stat3.isFIFO() ? "FIFO" : stat3.isSocket() ? "Socket" : "Unknown",
+  mtime: fromNullable(stat3.mtime),
+  atime: fromNullable(stat3.atime),
+  birthtime: fromNullable(stat3.birthtime),
+  dev: stat3.dev,
+  rdev: fromNullable(stat3.rdev),
+  ino: fromNullable(stat3.ino),
+  mode: stat3.mode,
+  nlink: fromNullable(stat3.nlink),
+  uid: fromNullable(stat3.uid),
+  gid: fromNullable(stat3.gid),
+  size: Size(stat3.size),
+  blksize: map(fromNullable(stat3.blksize), Size),
+  blocks: fromNullable(stat3.blocks)
+});
+var stat2 = /* @__PURE__ */ (() => {
+  const nodeStat = /* @__PURE__ */ effectify(NFS.stat, /* @__PURE__ */ handleErrnoException("FileSystem", "stat"), /* @__PURE__ */ handleBadArgument("stat"));
+  return (path) => map2(nodeStat(path), 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 !== void 0 ? Number(length) : void 0);
+})();
+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, options) => asyncScoped((emit) => acquireRelease(sync(() => {
+  const watcher = NFS.watch(path, {
+    recursive: options?.recursive
+  }, (event, path2) => {
+    if (!path2) return;
+    switch (event) {
+      case "rename": {
+        emit.fromEffect(matchEffect(stat2(path2), {
+          onSuccess: (_) => succeed(WatchEventCreate({
+            path: path2
+          })),
+          onFailure: (err) => err._tag === "SystemError" && err.reason === "NotFound" ? succeed(WatchEventRemove({
+            path: path2
+          })) : fail2(err)
+        }));
+        return;
+      }
+      case "change": {
+        emit.single(WatchEventUpdate({
+          path: path2
+        }));
+        return;
+      }
+    }
+  });
+  watcher.on("error", (error) => {
+    emit.fail(new SystemError({
+      module: "FileSystem",
+      reason: "Unknown",
+      method: "watch",
+      pathOrDescriptor: path,
+      cause: error
+    }));
+  });
+  watcher.on("close", () => {
+    emit.end();
+  });
+  return watcher;
+}), (watcher) => sync(() => watcher.close())));
+var watch2 = (backend, path, options) => stat2(path).pipe(map2((stat3) => backend.pipe(flatMap((_) => _.register(path, stat3, options)), getOrElse(() => watchNode(path, options)))), unwrap);
+var writeFile2 = (path, data, options) => async((resume, signal) => {
+  try {
+    NFS.writeFile(path, data, {
+      signal,
+      flag: options?.flag,
+      mode: options?.mode
+    }, (err) => {
+      if (err) {
+        resume(fail2(handleErrnoException("FileSystem", "writeFile")(err, [path])));
+      } else {
+        resume(_void);
+      }
+    });
+  } catch (err) {
+    resume(fail2(handleBadArgument("writeFile")(err)));
+  }
+});
+var makeFileSystem = /* @__PURE__ */ map2(/* @__PURE__ */ serviceOption(WatchBackend), (backend) => make4({
+  access: access2,
+  chmod: chmod2,
+  chown: chown2,
+  copy,
+  copyFile: copyFile2,
+  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 layer3 = /* @__PURE__ */ effect(FileSystem, makeFileSystem);
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/NodeFileSystem.js
+var layer4 = layer3;
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/internal/path.js
+import * as NodePath from "node:path";
+import * as NodeUrl from "node:url";
+var fromFileUrl = (url) => try_({
+  try: () => NodeUrl.fileURLToPath(url),
+  catch: (error) => new BadArgument({
+    module: "Path",
+    method: "fromFileUrl",
+    description: `Invalid file URL: ${url}`,
+    cause: error
+  })
+});
+var toFileUrl = (path) => try_({
+  try: () => NodeUrl.pathToFileURL(path),
+  catch: (error) => new BadArgument({
+    module: "Path",
+    method: "toFileUrl",
+    description: `Invalid path: ${path}`,
+    cause: error
+  })
+});
+var layerPosix = /* @__PURE__ */ succeed2(Path, /* @__PURE__ */ Path.of({
+  [TypeId]: TypeId,
+  ...NodePath.posix,
+  fromFileUrl,
+  toFileUrl
+}));
+var layerWin32 = /* @__PURE__ */ succeed2(Path, /* @__PURE__ */ Path.of({
+  [TypeId]: TypeId,
+  ...NodePath.win32,
+  fromFileUrl,
+  toFileUrl
+}));
+var layer5 = /* @__PURE__ */ succeed2(Path, /* @__PURE__ */ Path.of({
+  [TypeId]: TypeId,
+  ...NodePath,
+  fromFileUrl,
+  toFileUrl
+}));
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/NodePath.js
+var layer6 = layer5;
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/internal/terminal.js
+import * as readline from "node:readline";
+var defaultShouldQuit = (input) => input.key.ctrl && (input.key.name === "c" || input.key.name === "d");
+var make6 = /* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQuit) {
+  const stdin2 = process.stdin;
+  const stdout = process.stdout;
+  const rlRef = yield* make3({
+    acquire: acquireRelease(sync(() => {
+      const rl = readline.createInterface({
+        input: stdin2,
+        escapeCodeTimeout: 50
+      });
+      readline.emitKeypressEvents(stdin2, rl);
+      if (stdin2.isTTY) {
+        stdin2.setRawMode(true);
+      }
+      return rl;
+    }), (rl) => sync(() => {
+      if (stdin2.isTTY) {
+        stdin2.setRawMode(false);
+      }
+      rl.close();
+    }))
+  });
+  const columns = sync(() => stdout.columns ?? 0);
+  const rows = sync(() => stdout.rows ?? 0);
+  const isTTY = sync(() => Boolean(stdout.isTTY));
+  const readInput = gen(function* () {
+    yield* get(rlRef);
+    const mailbox = yield* make5();
+    const handleKeypress = (s, k) => {
+      const userInput = {
+        input: fromNullable(s),
+        key: {
+          name: k.name ?? "",
+          ctrl: !!k.ctrl,
+          meta: !!k.meta,
+          shift: !!k.shift
+        }
+      };
+      mailbox.unsafeOffer(userInput);
+      if (shouldQuit(userInput)) {
+        mailbox.unsafeDone(void_);
+      }
+    };
+    yield* addFinalizer2(() => sync(() => stdin2.off("keypress", handleKeypress)));
+    stdin2.on("keypress", handleKeypress);
+    return mailbox;
+  });
+  const readLine = get(rlRef).pipe(flatMap2((readlineInterface) => async((resume) => {
+    const onLine = (line) => resume(succeed(line));
+    readlineInterface.once("line", onLine);
+    return sync(() => readlineInterface.off("line", onLine));
+  })), scoped);
+  const display = (prompt) => uninterruptible(async((resume) => {
+    stdout.write(prompt, (err) => err ? resume(fail2(new BadArgument({
+      module: "Terminal",
+      method: "display",
+      description: "Failed to write prompt to stdout",
+      cause: err
+    }))) : resume(_void));
+  }));
+  return Terminal.of({
+    columns,
+    rows,
+    isTTY,
+    readInput,
+    readLine,
+    display
+  });
+});
+var layer7 = /* @__PURE__ */ scoped2(Terminal, /* @__PURE__ */ make6(defaultShouldQuit));
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/NodeTerminal.js
+var layer8 = layer7;
+
+// node_modules/.pnpm/@effect+platform-node@0.107.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effect@3.2_9535e05eb804fa0fb275ce283b448483/node_modules/@effect/platform-node/dist/esm/internal/worker.js
+var platformWorkerImpl = /* @__PURE__ */ makePlatform()({
+  setup({
+    scope,
+    worker
+  }) {
+    return flatMap2(make2(), (exitDeferred) => {
+      const thing = "postMessage" in worker ? {
+        postMessage(msg, t) {
+          worker.postMessage(msg, t);
+        },
+        kill: () => worker.terminate(),
+        worker
+      } : {
+        postMessage(msg, _) {
+          worker.send(msg);
+        },
+        kill: () => worker.kill("SIGKILL"),
+        worker
+      };
+      worker.on("exit", () => {
+        unsafeDone(exitDeferred, void_);
+      });
+      return as(addFinalizer(scope, suspend(() => {
+        thing.postMessage([1]);
+        return _await(exitDeferred);
+      }).pipe(interruptible, timeout(5e3), catchAllCause(() => sync(() => thing.kill())))), thing);
+    });
+  },
+  listen({
+    deferred,
+    emit,
+    port
+  }) {
+    port.worker.on("message", (message) => {
+      emit(message);
+    });
+    port.worker.on("messageerror", (cause) => {
+      unsafeDone(deferred, new WorkerError({
+        reason: "decode",
+        cause
+      }));
+    });
+    port.worker.on("error", (cause) => {
+      unsafeDone(deferred, new WorkerError({
+        reason: "unknown",
+        cause
+      }));
+    });
+    port.worker.on("exit", (code) => {
+      unsafeDone(deferred, new WorkerError({
+        reason: "unknown",
+        cause: new Error(`exited with code ${code}`)
+      }));
+    });
+    return _void;
+  }
+});
+var layerWorker = /* @__PURE__ */ succeed2(PlatformWorker, platformWorkerImpl);
+var layerManager2 = /* @__PURE__ */ provide(layerManager, layerWorker);
+
+// node_modules/.pnpm/@effect+platform-node@0.107.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effect@3.2_9535e05eb804fa0fb275ce283b448483/node_modules/@effect/platform-node/dist/esm/NodeWorker.js
+var layerManager3 = layerManager2;
+
+// node_modules/.pnpm/@effect+platform-node@0.107.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effect@3.2_9535e05eb804fa0fb275ce283b448483/node_modules/@effect/platform-node/dist/esm/NodeContext.js
+var layer10 = /* @__PURE__ */ pipe(/* @__PURE__ */ mergeAll(layer6, layer2, layer8, layerManager3), /* @__PURE__ */ provideMerge(layer4));
+
+// node_modules/.pnpm/@effect+platform-node@0.107.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effect@3.2_9535e05eb804fa0fb275ce283b448483/node_modules/@effect/platform-node/dist/esm/NodeRuntime.js
+var NodeRuntime_exports = {};
+__export(NodeRuntime_exports, {
+  runMain: () => runMain3
+});
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/internal/runtime.js
+var runMain = /* @__PURE__ */ makeRunMain(({
+  fiber,
+  teardown
+}) => {
+  const keepAlive = setInterval(constVoid, 2 ** 31 - 1);
+  let receivedSignal = false;
+  fiber.addObserver((exit) => {
+    if (!receivedSignal) {
+      process.removeListener("SIGINT", onSigint);
+      process.removeListener("SIGTERM", onSigint);
+    }
+    clearInterval(keepAlive);
+    teardown(exit, (code) => {
+      if (receivedSignal || code !== 0) {
+        process.exit(code);
+      }
+    });
+  });
+  function onSigint() {
+    receivedSignal = true;
+    process.removeListener("SIGINT", onSigint);
+    process.removeListener("SIGTERM", onSigint);
+    fiber.unsafeInterruptAsFork(fiber.id());
+  }
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigint);
+});
+
+// node_modules/.pnpm/@effect+platform-node-shared@0.60.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effe_4357e823b93d5894c803d1b4f92be74a/node_modules/@effect/platform-node-shared/dist/esm/NodeRuntime.js
+var runMain2 = runMain;
+
+// node_modules/.pnpm/@effect+platform-node@0.107.0_@effect+cluster@0.59.0_@effect+platform@0.96.2_effect@3.2_9535e05eb804fa0fb275ce283b448483/node_modules/@effect/platform-node/dist/esm/NodeRuntime.js
+var runMain3 = runMain2;
+
+export {
+  fromReadable,
+  layer10 as layer,
+  NodeContext_exports,
+  runMain3 as runMain,
+  NodeRuntime_exports
+};