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

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

@@ -0,0 +1,93 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunRedis.js
+var BunRedis_exports = {};
+__export(BunRedis_exports, {
+  BunRedis: () => BunRedis,
+  layer: () => layer,
+  layerConfig: () => layerConfig
+});
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Fn from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as Redis from "effect/unstable/persistence/Redis";
+var BunRedis = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-bun/BunRedis")) {
+};
+var make4 = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const {
+    RedisClient
+  } = yield* Effect.promise(() => import("bun"));
+  const scope2 = yield* Effect.scope;
+  yield* Scope.addFinalizer(scope2, Effect.sync(() => client.close()));
+  const client = new RedisClient(options?.url, options);
+  const use = (f) => Effect.tryPromise({
+    try: () => f(client),
+    catch: (cause) => new Redis.RedisError({
+      cause
+    })
+  });
+  const redis = yield* Redis.make({
+    send: (command, ...args) => Effect.tryPromise({
+      try: () => client.send(command, args),
+      catch: (cause) => new Redis.RedisError({
+        cause
+      })
+    }),
+    subscribe: (channel, onMessage) => Effect.gen(function* () {
+      const terminal = yield* Deferred.make();
+      yield* Effect.acquireRelease(Effect.tryPromise({
+        try: async () => {
+          const subscriber = new RedisClient(options?.url, {
+            ...options,
+            autoReconnect: false
+          });
+          subscriber.onclose = (cause) => {
+            Deferred.doneUnsafe(terminal, new Redis.RedisError({
+              cause
+            }));
+          };
+          try {
+            await subscriber.subscribe(channel, (message, channel2) => {
+              onMessage({
+                channel: channel2,
+                message
+              });
+            });
+            return subscriber;
+          } catch (cause) {
+            subscriber.onclose = null;
+            subscriber.close();
+            throw cause;
+          }
+        },
+        catch: (cause) => new Redis.RedisError({
+          cause
+        })
+      }), (subscriber) => Effect.sync(() => {
+        subscriber.onclose = null;
+        subscriber.close();
+      }));
+      return Deferred.await(terminal);
+    })
+  });
+  const bunRedis = Fn.identity({
+    client,
+    use
+  });
+  return Context.make(BunRedis, bunRedis).pipe(Context.add(Redis.Redis, redis));
+});
+var layer = (options) => Layer.effectContext(make4(options));
+var layerConfig = (options) => Layer.effectContext(Config.unwrap(options).pipe(Effect.flatMap(make4)));
+
+export {
+  BunRedis,
+  layer,
+  layerConfig,
+  BunRedis_exports
+};

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

@@ -0,0 +1,28 @@
+import {
+  IncomingMessage,
+  layer,
+  layerTls,
+  layerWebSocket,
+  make,
+  makeTls,
+  makeWebSocket
+} from "./chunk-DWSHTSVX.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/NodeSocketServer.js
+var NodeSocketServer_exports = {};
+__export(NodeSocketServer_exports, {
+  IncomingMessage: () => IncomingMessage,
+  layer: () => layer,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  make: () => make,
+  makeTls: () => makeTls,
+  makeWebSocket: () => makeWebSocket
+});
+
+export {
+  NodeSocketServer_exports
+};

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

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-UFH5UUZK.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunCrypto.js
+var BunCrypto_exports = {};
+__export(BunCrypto_exports, {
+  layer: () => layer2
+});
+var layer2 = layer;
+
+export {
+  layer2 as layer,
+  BunCrypto_exports
+};

package/dist/vendor/chunk-B3FZ67QU.js

@@ -0,0 +1,59 @@
+import {
+  fromReadable
+} from "./chunk-XH4U3JSV.js";
+import {
+  fromWritable
+} from "./chunk-OXNGN5H7.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/NodeStdio.js
+var NodeStdio_exports = {};
+__export(NodeStdio_exports, {
+  layer: () => layer
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { systemError } from "effect/PlatformError";
+import * as Stdio from "effect/Stdio";
+var layer = /* @__PURE__ */ Layer.succeed(Stdio.Stdio, /* @__PURE__ */ Stdio.make({
+  args: /* @__PURE__ */ Effect.sync(() => process.argv.slice(2)),
+  stdinIsTerminal: /* @__PURE__ */ Effect.sync(() => process.stdin.isTTY === true),
+  stdoutIsTerminal: /* @__PURE__ */ Effect.sync(() => process.stdout.isTTY === true),
+  stdout: (options) => fromWritable({
+    evaluate: () => process.stdout,
+    onError: (cause) => systemError({
+      module: "Stdio",
+      method: "stdout",
+      _tag: "Unknown",
+      cause
+    }),
+    endOnDone: options?.endOnDone ?? false
+  }),
+  stderr: (options) => fromWritable({
+    evaluate: () => process.stderr,
+    onError: (cause) => systemError({
+      module: "Stdio",
+      method: "stderr",
+      _tag: "Unknown",
+      cause
+    }),
+    endOnDone: options?.endOnDone ?? false
+  }),
+  stdin: /* @__PURE__ */ fromReadable({
+    evaluate: () => process.stdin,
+    onError: (cause) => systemError({
+      module: "Stdio",
+      method: "stdin",
+      _tag: "Unknown",
+      cause
+    }),
+    closeOnDone: false
+  })
+}));
+
+export {
+  layer,
+  NodeStdio_exports
+};

package/dist/vendor/chunk-BBLQEPNJ.js

@@ -0,0 +1,22 @@
+import {
+  layer,
+  make
+} from "./chunk-TXKLEBBL.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunTerminal.js
+var BunTerminal_exports = {};
+__export(BunTerminal_exports, {
+  layer: () => layer2,
+  make: () => make2
+});
+var make2 = make;
+var layer2 = layer;
+
+export {
+  make2 as make,
+  layer2 as layer,
+  BunTerminal_exports
+};

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
+};