@holoscript/std 6.0.3 → 7.0.1

package/dist/fs/index.cjs

@@ -0,0 +1,1049 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/fs/index.ts
+var fs_exports = {};
+__export(fs_exports, {
+  FileWatcher: () => FileWatcher,
+  PathBuilder: () => PathBuilder,
+  addSuffix: () => addSuffix,
+  appendLine: () => appendLine,
+  appendLineSync: () => appendLineSync,
+  appendText: () => appendText,
+  appendTextSync: () => appendTextSync,
+  basename: () => basename2,
+  changeExtension: () => changeExtension,
+  chdir: () => chdir,
+  commonBase: () => commonBase,
+  copy: () => copy,
+  copySync: () => copySync,
+  createTempDir: () => createTempDir,
+  createTempFile: () => createTempFile,
+  cwd: () => cwd,
+  delimiter: () => delimiter2,
+  dirSize: () => dirSize,
+  dirname: () => dirname3,
+  ensureDir: () => ensureDir,
+  ensureDirSync: () => ensureDirSync,
+  ensureFile: () => ensureFile,
+  ensureFileSync: () => ensureFileSync,
+  exists: () => exists,
+  existsSync: () => existsSync2,
+  expandHome: () => expandHome,
+  extname: () => extname2,
+  fileSize: () => fileSize,
+  fileSizeSync: () => fileSizeSync,
+  format: () => format2,
+  formatSize: () => formatSize,
+  glob: () => glob,
+  globSync: () => globSync,
+  hasExtension: () => hasExtension,
+  homeDir: () => homeDir,
+  isAbsolute: () => isAbsolute3,
+  isChildOf: () => isChildOf,
+  isDirectory: () => isDirectory,
+  isDirectorySync: () => isDirectorySync,
+  isFile: () => isFile,
+  isFileSync: () => isFileSync,
+  isLinux: () => isLinux,
+  isMacOS: () => isMacOS,
+  isWindows: () => isWindows,
+  join: () => join3,
+  listDirs: () => listDirs,
+  listDirsSync: () => listDirsSync,
+  listFiles: () => listFiles,
+  listFilesSync: () => listFilesSync,
+  matchesPattern: () => matchesPattern,
+  mkdir: () => mkdir2,
+  mkdirSync: () => mkdirSync2,
+  move: () => move,
+  moveSync: () => moveSync,
+  normalize: () => normalize2,
+  parent: () => parent,
+  parse: () => parse2,
+  path: () => path,
+  readBytes: () => readBytes,
+  readBytesSync: () => readBytesSync,
+  readDir: () => readDir,
+  readDirSync: () => readDirSync,
+  readJson: () => readJson,
+  readJsonSync: () => readJsonSync,
+  readLines: () => readLines,
+  readLinesSync: () => readLinesSync,
+  readText: () => readText,
+  readTextSync: () => readTextSync,
+  relative: () => relative3,
+  remove: () => remove,
+  removeExtension: () => removeExtension,
+  removeSync: () => removeSync,
+  resolve: () => resolve3,
+  sanitize: () => sanitize,
+  segments: () => segments,
+  sep: () => sep2,
+  stat: () => stat2,
+  statSync: () => statSync2,
+  tempDir: () => tempDir,
+  toPosix: () => toPosix,
+  toWindows: () => toWindows,
+  walk: () => walk,
+  watch: () => watch,
+  watchBatched: () => watchBatched,
+  watchCallback: () => watchCallback,
+  watchDebounced: () => watchDebounced,
+  watchDirs: () => watchDirs,
+  watchEvents: () => watchEvents,
+  watchFile: () => watchFile,
+  watchFileTypes: () => watchFileTypes,
+  watchFiles: () => watchFiles,
+  watchFiltered: () => watchFiltered,
+  watchOnce: () => watchOnce,
+  writeBytes: () => writeBytes,
+  writeBytesSync: () => writeBytesSync,
+  writeJson: () => writeJson,
+  writeJsonSync: () => writeJsonSync,
+  writeText: () => writeText,
+  writeTextSync: () => writeTextSync
+});
+module.exports = __toCommonJS(fs_exports);
+
+// src/fs/fs.ts
+var fs = __toESM(require("fs"), 1);
+var fsPromises = __toESM(require("fs/promises"), 1);
+var nodePath = __toESM(require("path"), 1);
+var import_glob = require("glob");
+
+// src/fs/sandbox.ts
+var import_path = require("path");
+var SANDBOX_ROOT_ENV = "HOLOSCRIPT_FS_SANDBOX_ROOT";
+var PathBoundaryError = class extends Error {
+  code = "ERR_PATH_BOUNDARY";
+  attemptedPath;
+  sandboxRoot;
+  constructor(attemptedPath, sandboxRoot) {
+    super(
+      `[@holoscript/std/fs] path "${attemptedPath}" resolves outside sandbox root "${sandboxRoot}"`
+    );
+    this.name = "PathBoundaryError";
+    this.attemptedPath = attemptedPath;
+    this.sandboxRoot = sandboxRoot;
+  }
+};
+function getSandboxRoot() {
+  const raw = process.env[SANDBOX_ROOT_ENV];
+  if (!raw || raw.trim() === "") return null;
+  return (0, import_path.resolve)(raw.trim());
+}
+function enforcePathBoundary(path2) {
+  const root = getSandboxRoot();
+  if (root === null) return path2;
+  if (typeof path2 !== "string") {
+    throw new TypeError(`[@holoscript/std/fs] path must be a string, got ${typeof path2}`);
+  }
+  const absolute = (0, import_path.isAbsolute)(path2) ? (0, import_path.resolve)(path2) : (0, import_path.resolve)(root, path2);
+  const rel = (0, import_path.relative)(root, absolute);
+  if (rel === "" || !rel.startsWith("..") && !(0, import_path.isAbsolute)(rel)) {
+    return absolute;
+  }
+  throw new PathBoundaryError(path2, root);
+}
+
+// src/fs/fs.ts
+async function readText(path2, encoding = "utf-8") {
+  path2 = enforcePathBoundary(path2);
+  return fsPromises.readFile(path2, { encoding });
+}
+function readTextSync(path2, encoding = "utf-8") {
+  path2 = enforcePathBoundary(path2);
+  return fs.readFileSync(path2, { encoding });
+}
+async function readBytes(path2) {
+  path2 = enforcePathBoundary(path2);
+  return fsPromises.readFile(path2);
+}
+function readBytesSync(path2) {
+  path2 = enforcePathBoundary(path2);
+  return fs.readFileSync(path2);
+}
+async function readJson(path2) {
+  const text = await readText(path2);
+  return JSON.parse(text);
+}
+function readJsonSync(path2) {
+  const text = readTextSync(path2);
+  return JSON.parse(text);
+}
+async function readLines(path2, encoding = "utf-8") {
+  const text = await readText(path2, encoding);
+  return text.split(/\r?\n/);
+}
+function readLinesSync(path2, encoding = "utf-8") {
+  const text = readTextSync(path2, encoding);
+  return text.split(/\r?\n/);
+}
+async function writeText(path2, content, options = {}) {
+  path2 = enforcePathBoundary(path2);
+  const { encoding = "utf-8", mode, flag = options.append ? "a" : "w" } = options;
+  await ensureDir(nodePath.dirname(path2));
+  await fsPromises.writeFile(path2, content, { encoding, mode, flag });
+}
+function writeTextSync(path2, content, options = {}) {
+  path2 = enforcePathBoundary(path2);
+  const { encoding = "utf-8", mode, flag = options.append ? "a" : "w" } = options;
+  ensureDirSync(nodePath.dirname(path2));
+  fs.writeFileSync(path2, content, { encoding, mode, flag });
+}
+async function writeBytes(path2, content, options = {}) {
+  path2 = enforcePathBoundary(path2);
+  const { mode, flag = options.append ? "a" : "w" } = options;
+  await ensureDir(nodePath.dirname(path2));
+  await fsPromises.writeFile(path2, content, { mode, flag });
+}
+function writeBytesSync(path2, content, options = {}) {
+  path2 = enforcePathBoundary(path2);
+  const { mode, flag = options.append ? "a" : "w" } = options;
+  ensureDirSync(nodePath.dirname(path2));
+  fs.writeFileSync(path2, content, { mode, flag });
+}
+async function writeJson(path2, data, options = {}) {
+  const { pretty = true, ...writeOpts } = options;
+  const text = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+  await writeText(path2, text, writeOpts);
+}
+function writeJsonSync(path2, data, options = {}) {
+  const { pretty = true, ...writeOpts } = options;
+  const text = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+  writeTextSync(path2, text, writeOpts);
+}
+async function appendText(path2, content, encoding = "utf-8") {
+  await writeText(path2, content, { encoding, append: true });
+}
+function appendTextSync(path2, content, encoding = "utf-8") {
+  writeTextSync(path2, content, { encoding, append: true });
+}
+async function appendLine(path2, line, encoding = "utf-8") {
+  await appendText(path2, line + "\n", encoding);
+}
+function appendLineSync(path2, line, encoding = "utf-8") {
+  appendTextSync(path2, line + "\n", encoding);
+}
+async function exists(path2) {
+  path2 = enforcePathBoundary(path2);
+  try {
+    await fsPromises.access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function existsSync2(path2) {
+  path2 = enforcePathBoundary(path2);
+  return fs.existsSync(path2);
+}
+async function isFile(path2) {
+  path2 = enforcePathBoundary(path2);
+  try {
+    const stats = await fsPromises.stat(path2);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+function isFileSync(path2) {
+  path2 = enforcePathBoundary(path2);
+  try {
+    return fs.statSync(path2).isFile();
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(path2) {
+  path2 = enforcePathBoundary(path2);
+  try {
+    const stats = await fsPromises.stat(path2);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isDirectorySync(path2) {
+  path2 = enforcePathBoundary(path2);
+  try {
+    return fs.statSync(path2).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function stat2(path2) {
+  path2 = enforcePathBoundary(path2);
+  const stats = await fsPromises.stat(path2);
+  return {
+    size: stats.size,
+    isFile: stats.isFile(),
+    isDirectory: stats.isDirectory(),
+    isSymlink: stats.isSymbolicLink(),
+    createdAt: stats.birthtime,
+    modifiedAt: stats.mtime,
+    accessedAt: stats.atime,
+    mode: stats.mode
+  };
+}
+function statSync2(path2) {
+  path2 = enforcePathBoundary(path2);
+  const stats = fs.statSync(path2);
+  return {
+    size: stats.size,
+    isFile: stats.isFile(),
+    isDirectory: stats.isDirectory(),
+    isSymlink: stats.isSymbolicLink(),
+    createdAt: stats.birthtime,
+    modifiedAt: stats.mtime,
+    accessedAt: stats.atime,
+    mode: stats.mode
+  };
+}
+async function mkdir2(path2, recursive = true) {
+  path2 = enforcePathBoundary(path2);
+  await fsPromises.mkdir(path2, { recursive });
+}
+function mkdirSync2(path2, recursive = true) {
+  path2 = enforcePathBoundary(path2);
+  fs.mkdirSync(path2, { recursive });
+}
+async function ensureDir(path2) {
+  if (!await exists(path2)) {
+    await mkdir2(path2, true);
+  }
+}
+function ensureDirSync(path2) {
+  if (!existsSync2(path2)) {
+    mkdirSync2(path2, true);
+  }
+}
+async function ensureFile(path2) {
+  path2 = enforcePathBoundary(path2);
+  if (!await exists(path2)) {
+    await ensureDir(nodePath.dirname(path2));
+    await writeText(path2, "");
+  }
+}
+function ensureFileSync(path2) {
+  path2 = enforcePathBoundary(path2);
+  if (!existsSync2(path2)) {
+    ensureDirSync(nodePath.dirname(path2));
+    writeTextSync(path2, "");
+  }
+}
+async function remove(path2, recursive = true) {
+  path2 = enforcePathBoundary(path2);
+  await fsPromises.rm(path2, { recursive, force: true });
+}
+function removeSync(path2, recursive = true) {
+  path2 = enforcePathBoundary(path2);
+  fs.rmSync(path2, { recursive, force: true });
+}
+async function copy(src, dest, options = {}) {
+  src = enforcePathBoundary(src);
+  dest = enforcePathBoundary(dest);
+  const { overwrite = true, recursive = true, filter } = options;
+  if (filter && !filter(src)) return;
+  const srcStat = await stat2(src);
+  if (srcStat.isDirectory) {
+    await ensureDir(dest);
+    if (recursive) {
+      const entries = await readDir(src);
+      for (const entry of entries) {
+        await copy(entry.path, nodePath.join(dest, entry.name), options);
+      }
+    }
+  } else {
+    if (!overwrite && await exists(dest)) {
+      return;
+    }
+    await ensureDir(nodePath.dirname(dest));
+    await fsPromises.copyFile(src, dest);
+  }
+}
+function copySync(src, dest, options = {}) {
+  src = enforcePathBoundary(src);
+  dest = enforcePathBoundary(dest);
+  const { overwrite = true, recursive = true, filter } = options;
+  if (filter && !filter(src)) return;
+  const srcStat = statSync2(src);
+  if (srcStat.isDirectory) {
+    ensureDirSync(dest);
+    if (recursive) {
+      const entries = readDirSync(src);
+      for (const entry of entries) {
+        copySync(entry.path, nodePath.join(dest, entry.name), options);
+      }
+    }
+  } else {
+    if (!overwrite && existsSync2(dest)) {
+      return;
+    }
+    ensureDirSync(nodePath.dirname(dest));
+    fs.copyFileSync(src, dest);
+  }
+}
+async function move(src, dest, overwrite = true) {
+  src = enforcePathBoundary(src);
+  dest = enforcePathBoundary(dest);
+  if (!overwrite && await exists(dest)) {
+    throw new Error(`Destination already exists: ${dest}`);
+  }
+  await ensureDir(nodePath.dirname(dest));
+  await fsPromises.rename(src, dest);
+}
+function moveSync(src, dest, overwrite = true) {
+  src = enforcePathBoundary(src);
+  dest = enforcePathBoundary(dest);
+  if (!overwrite && existsSync2(dest)) {
+    throw new Error(`Destination already exists: ${dest}`);
+  }
+  ensureDirSync(nodePath.dirname(dest));
+  fs.renameSync(src, dest);
+}
+async function readDir(path2) {
+  path2 = enforcePathBoundary(path2);
+  const entries = await fsPromises.readdir(path2, { withFileTypes: true });
+  return entries.map((entry) => ({
+    name: entry.name,
+    path: nodePath.join(path2, entry.name),
+    isFile: entry.isFile(),
+    isDirectory: entry.isDirectory(),
+    isSymlink: entry.isSymbolicLink()
+  }));
+}
+function readDirSync(path2) {
+  path2 = enforcePathBoundary(path2);
+  const entries = fs.readdirSync(path2, { withFileTypes: true });
+  return entries.map((entry) => ({
+    name: entry.name,
+    path: nodePath.join(path2, entry.name),
+    isFile: entry.isFile(),
+    isDirectory: entry.isDirectory(),
+    isSymlink: entry.isSymbolicLink()
+  }));
+}
+async function listFiles(path2) {
+  const entries = await readDir(path2);
+  return entries.filter((e) => e.isFile).map((e) => e.name);
+}
+function listFilesSync(path2) {
+  const entries = readDirSync(path2);
+  return entries.filter((e) => e.isFile).map((e) => e.name);
+}
+async function listDirs(path2) {
+  const entries = await readDir(path2);
+  return entries.filter((e) => e.isDirectory).map((e) => e.name);
+}
+function listDirsSync(path2) {
+  const entries = readDirSync(path2);
+  return entries.filter((e) => e.isDirectory).map((e) => e.name);
+}
+async function* walk(path2, options = {}) {
+  const { depth = Infinity, followSymlinks = false } = options;
+  async function* walkDir(dir, currentDepth) {
+    if (currentDepth > depth) return;
+    const entries = await readDir(dir);
+    for (const entry of entries) {
+      yield entry;
+      if (entry.isDirectory || followSymlinks && entry.isSymlink) {
+        yield* walkDir(entry.path, currentDepth + 1);
+      }
+    }
+  }
+  yield* walkDir(path2, 0);
+}
+async function glob(pattern, options = {}) {
+  const { cwd: cwd2 = process.cwd(), ignore = [] } = options;
+  return (0, import_glob.glob)(pattern, { cwd: cwd2, ignore, absolute: true });
+}
+function globSync(pattern, options = {}) {
+  const { cwd: cwd2 = process.cwd(), ignore = [] } = options;
+  return import_glob.glob.sync(pattern, { cwd: cwd2, ignore, absolute: true });
+}
+function tempDir() {
+  return require("os").tmpdir();
+}
+async function createTempFile(prefix = "tmp-", suffix = "", dir) {
+  const tempDirectory = dir || tempDir();
+  const filename = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}${suffix}`;
+  const filePath = nodePath.join(tempDirectory, filename);
+  await writeText(filePath, "");
+  return {
+    path: filePath,
+    cleanup: async () => {
+      await remove(filePath);
+    }
+  };
+}
+async function createTempDir(prefix = "tmp-") {
+  const tempDirectory = tempDir();
+  const dirname4 = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const dirPath = nodePath.join(tempDirectory, dirname4);
+  await mkdir2(dirPath);
+  return {
+    path: dirPath,
+    cleanup: async () => {
+      await remove(dirPath, true);
+    }
+  };
+}
+async function fileSize(path2) {
+  const stats = await stat2(path2);
+  return stats.size;
+}
+function fileSizeSync(path2) {
+  const stats = statSync2(path2);
+  return stats.size;
+}
+async function dirSize(path2) {
+  let total = 0;
+  for await (const entry of walk(path2)) {
+    if (entry.isFile) {
+      total += await fileSize(entry.path);
+    }
+  }
+  return total;
+}
+function formatSize(bytes, decimals = 2) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)) + " " + sizes[i];
+}
+
+// src/fs/path.ts
+var nodePath2 = __toESM(require("path"), 1);
+var sep2 = nodePath2.sep;
+var delimiter2 = nodePath2.delimiter;
+function join3(...paths) {
+  return nodePath2.join(...paths);
+}
+function resolve3(...paths) {
+  return nodePath2.resolve(...paths);
+}
+function relative3(from, to) {
+  return nodePath2.relative(from, to);
+}
+function normalize2(p) {
+  return nodePath2.normalize(p);
+}
+function isAbsolute3(p) {
+  return nodePath2.isAbsolute(p);
+}
+function dirname3(p) {
+  return nodePath2.dirname(p);
+}
+function basename2(p, ext) {
+  return nodePath2.basename(p, ext);
+}
+function extname2(p) {
+  return nodePath2.extname(p);
+}
+function parse2(p) {
+  return nodePath2.parse(p);
+}
+function format2(pathObject) {
+  return nodePath2.format(pathObject);
+}
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function toWindows(p) {
+  return p.replace(/\//g, "\\");
+}
+function parent(p) {
+  return dirname3(p);
+}
+function segments(p) {
+  const normalized = normalize2(p);
+  return normalized.split(sep2).filter((s) => s.length > 0);
+}
+function hasExtension(p, ext) {
+  const pathExt = extname2(p).toLowerCase();
+  const checkExt = ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`;
+  return pathExt === checkExt;
+}
+function changeExtension(p, newExt) {
+  const parsed = parse2(p);
+  const ext = newExt.startsWith(".") ? newExt : `.${newExt}`;
+  return join3(parsed.dir, `${parsed.name}${ext}`);
+}
+function removeExtension(p) {
+  const parsed = parse2(p);
+  return join3(parsed.dir, parsed.name);
+}
+function addSuffix(p, suffix) {
+  const parsed = parse2(p);
+  return join3(parsed.dir, `${parsed.name}${suffix}${parsed.ext}`);
+}
+function isChildOf(child, parent2) {
+  const childResolved = resolve3(child);
+  const parentResolved = resolve3(parent2);
+  const rel = relative3(parentResolved, childResolved);
+  return !rel.startsWith("..") && !isAbsolute3(rel);
+}
+function commonBase(...paths) {
+  if (paths.length === 0) return "";
+  if (paths.length === 1) return dirname3(paths[0]);
+  const resolvedPaths = paths.map((p) => resolve3(p));
+  const segmentsList = resolvedPaths.map((p) => segments(p));
+  const minLength = Math.min(...segmentsList.map((s) => s.length));
+  const common = [];
+  for (let i = 0; i < minLength; i++) {
+    const segment = segmentsList[0][i];
+    if (segmentsList.every((s) => s[i] === segment)) {
+      common.push(segment);
+    } else {
+      break;
+    }
+  }
+  if (common.length === 0) return "";
+  if (resolvedPaths[0].startsWith("/")) {
+    return "/" + common.join("/");
+  }
+  return common.join(sep2);
+}
+function expandHome(p) {
+  if (p.startsWith("~")) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    return join3(home, p.slice(1));
+  }
+  return p;
+}
+function sanitize(filename) {
+  return filename.replace(/[<>:"/\\|?*\x00-\x1F]/g, "_").replace(/^\.+/, "_").replace(/\.+$/, "_").slice(0, 255);
+}
+function matchesPattern(filename, pattern) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${regexPattern}$`).test(filename);
+}
+var PathBuilder = class _PathBuilder {
+  path;
+  constructor(base = process.cwd()) {
+    this.path = resolve3(base);
+  }
+  static from(base) {
+    return new _PathBuilder(base);
+  }
+  static cwd() {
+    return new _PathBuilder(process.cwd());
+  }
+  join(...segments2) {
+    this.path = join3(this.path, ...segments2);
+    return this;
+  }
+  parent() {
+    this.path = dirname3(this.path);
+    return this;
+  }
+  sibling(name) {
+    this.path = join3(dirname3(this.path), name);
+    return this;
+  }
+  withExtension(ext) {
+    this.path = changeExtension(this.path, ext);
+    return this;
+  }
+  withSuffix(suffix) {
+    this.path = addSuffix(this.path, suffix);
+    return this;
+  }
+  normalize() {
+    this.path = normalize2(this.path);
+    return this;
+  }
+  toString() {
+    return this.path;
+  }
+  get value() {
+    return this.path;
+  }
+  get dirname() {
+    return dirname3(this.path);
+  }
+  get basename() {
+    return basename2(this.path);
+  }
+  get extname() {
+    return extname2(this.path);
+  }
+  get name() {
+    return parse2(this.path).name;
+  }
+};
+function path(base) {
+  return new PathBuilder(base);
+}
+
+// src/fs/watch.ts
+var import_chokidar = __toESM(require("chokidar"), 1);
+var import_events = require("events");
+var FileWatcher = class extends import_events.EventEmitter {
+  watcher = null;
+  paths;
+  options;
+  debounceTimers = /* @__PURE__ */ new Map();
+  constructor(paths, options = {}) {
+    super();
+    this.paths = Array.isArray(paths) ? paths : [paths];
+    this.options = {
+      ignored: options.ignored || ["**/node_modules/**", "**/.git/**"],
+      usePolling: options.usePolling || false,
+      interval: options.interval || 100,
+      emitInitial: options.emitInitial ?? true,
+      followSymlinks: options.followSymlinks ?? true,
+      depth: options.depth,
+      persistent: options.persistent ?? true,
+      debounce: options.debounce || 0
+    };
+  }
+  /**
+   * Start watching
+   */
+  start() {
+    if (this.watcher) {
+      return this;
+    }
+    const chokidarOpts = {
+      ignored: this.options.ignored,
+      persistent: this.options.persistent,
+      followSymlinks: this.options.followSymlinks,
+      depth: this.options.depth,
+      usePolling: this.options.usePolling,
+      interval: this.options.interval,
+      ignoreInitial: !this.options.emitInitial
+    };
+    this.watcher = import_chokidar.default.watch(this.paths, chokidarOpts);
+    this.watcher.on("add", (path2, stats) => this.handleEvent("add", path2, stats));
+    this.watcher.on("change", (path2, stats) => this.handleEvent("change", path2, stats));
+    this.watcher.on("unlink", (path2) => this.handleEvent("unlink", path2));
+    this.watcher.on("addDir", (path2, stats) => this.handleEvent("addDir", path2, stats));
+    this.watcher.on("unlinkDir", (path2) => this.handleEvent("unlinkDir", path2));
+    this.watcher.on("error", (error) => this.emit("error", error));
+    this.watcher.on("ready", () => this.emit("ready"));
+    return this;
+  }
+  /**
+   * Stop watching
+   */
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+  }
+  /**
+   * Add paths to watch
+   */
+  add(paths) {
+    const pathsArray = Array.isArray(paths) ? paths : [paths];
+    this.paths.push(...pathsArray);
+    this.watcher?.add(pathsArray);
+    return this;
+  }
+  /**
+   * Remove paths from watch
+   */
+  unwatch(paths) {
+    const pathsArray = Array.isArray(paths) ? paths : [paths];
+    this.paths = this.paths.filter((p) => !pathsArray.includes(p));
+    this.watcher?.unwatch(pathsArray);
+    return this;
+  }
+  /**
+   * Get watched paths
+   */
+  getWatched() {
+    return this.watcher?.getWatched() || {};
+  }
+  /**
+   * Check if watcher is ready
+   */
+  get isReady() {
+    return this.watcher !== null;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  handleEvent(type, path2, stats) {
+    const event = {
+      type,
+      path: path2,
+      stats: stats ? {
+        size: stats.size,
+        mtime: stats.mtime
+      } : void 0
+    };
+    if (this.options.debounce && this.options.debounce > 0) {
+      if (this.debounceTimers.has(path2)) {
+        clearTimeout(this.debounceTimers.get(path2));
+      }
+      this.debounceTimers.set(
+        path2,
+        setTimeout(() => {
+          this.debounceTimers.delete(path2);
+          this.emitEvent(event);
+        }, this.options.debounce)
+      );
+    } else {
+      this.emitEvent(event);
+    }
+  }
+  emitEvent(event) {
+    this.emit(event.type, event);
+    this.emit("all", event);
+  }
+};
+function watch(paths, options) {
+  return new FileWatcher(paths, options).start();
+}
+function watchCallback(paths, callback, options) {
+  const watcher = watch(paths, options);
+  watcher.on("all", async (event) => {
+    try {
+      await callback(event);
+    } catch (error) {
+      watcher.emit("error", error);
+    }
+  });
+  return watcher;
+}
+function watchFileTypes(dir, extensions, callback, options) {
+  const patterns = extensions.map((ext) => {
+    const e = ext.startsWith(".") ? ext : `.${ext}`;
+    return `${dir}/**/*${e}`;
+  });
+  return watchCallback(patterns, callback, options);
+}
+function watchFile(path2, callback, options) {
+  return watchCallback(path2, callback, { ...options, depth: 0 });
+}
+function watchDebounced(paths, callback, debounceMs = 300, options) {
+  return watchCallback(paths, callback, { ...options, debounce: debounceMs });
+}
+async function watchOnce(paths, options) {
+  return new Promise((resolve4, reject) => {
+    const watcher = watch(paths, { ...options, emitInitial: false });
+    const cleanup = async () => {
+      await watcher.stop();
+    };
+    watcher.on("all", async (event) => {
+      await cleanup();
+      resolve4(event);
+    });
+    watcher.on("error", async (error) => {
+      await cleanup();
+      reject(error);
+    });
+  });
+}
+function watchBatched(paths, callback, batchMs = 100, options) {
+  const watcher = watch(paths, options);
+  let batch = [];
+  let timer = null;
+  const flush = async () => {
+    if (batch.length > 0) {
+      const events = [...batch];
+      batch = [];
+      try {
+        await callback(events);
+      } catch (error) {
+        watcher.emit("error", error);
+      }
+    }
+  };
+  watcher.on("all", (event) => {
+    batch.push(event);
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(flush, batchMs);
+  });
+  const originalStop = watcher.stop.bind(watcher);
+  watcher.stop = async () => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    await flush();
+    await originalStop();
+  };
+  return watcher;
+}
+function watchFiltered(paths, filter, callback, options) {
+  return watchCallback(
+    paths,
+    async (event) => {
+      if (filter(event)) {
+        await callback(event);
+      }
+    },
+    options
+  );
+}
+function watchEvents(paths, eventTypes, callback, options) {
+  return watchFiltered(paths, (event) => eventTypes.includes(event.type), callback, options);
+}
+function watchFiles(paths, callback, options) {
+  return watchEvents(paths, ["add", "change", "unlink"], callback, options);
+}
+function watchDirs(paths, callback, options) {
+  return watchEvents(paths, ["addDir", "unlinkDir"], callback, options);
+}
+
+// src/fs/index.ts
+function cwd() {
+  return process.cwd();
+}
+function chdir(path2) {
+  process.chdir(path2);
+}
+function homeDir() {
+  return require("os").homedir();
+}
+function isWindows() {
+  return process.platform === "win32";
+}
+function isMacOS() {
+  return process.platform === "darwin";
+}
+function isLinux() {
+  return process.platform === "linux";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileWatcher,
+  PathBuilder,
+  addSuffix,
+  appendLine,
+  appendLineSync,
+  appendText,
+  appendTextSync,
+  basename,
+  changeExtension,
+  chdir,
+  commonBase,
+  copy,
+  copySync,
+  createTempDir,
+  createTempFile,
+  cwd,
+  delimiter,
+  dirSize,
+  dirname,
+  ensureDir,
+  ensureDirSync,
+  ensureFile,
+  ensureFileSync,
+  exists,
+  existsSync,
+  expandHome,
+  extname,
+  fileSize,
+  fileSizeSync,
+  format,
+  formatSize,
+  glob,
+  globSync,
+  hasExtension,
+  homeDir,
+  isAbsolute,
+  isChildOf,
+  isDirectory,
+  isDirectorySync,
+  isFile,
+  isFileSync,
+  isLinux,
+  isMacOS,
+  isWindows,
+  join,
+  listDirs,
+  listDirsSync,
+  listFiles,
+  listFilesSync,
+  matchesPattern,
+  mkdir,
+  mkdirSync,
+  move,
+  moveSync,
+  normalize,
+  parent,
+  parse,
+  path,
+  readBytes,
+  readBytesSync,
+  readDir,
+  readDirSync,
+  readJson,
+  readJsonSync,
+  readLines,
+  readLinesSync,
+  readText,
+  readTextSync,
+  relative,
+  remove,
+  removeExtension,
+  removeSync,
+  resolve,
+  sanitize,
+  segments,
+  sep,
+  stat,
+  statSync,
+  tempDir,
+  toPosix,
+  toWindows,
+  walk,
+  watch,
+  watchBatched,
+  watchCallback,
+  watchDebounced,
+  watchDirs,
+  watchEvents,
+  watchFile,
+  watchFileTypes,
+  watchFiles,
+  watchFiltered,
+  watchOnce,
+  writeBytes,
+  writeBytesSync,
+  writeJson,
+  writeJsonSync,
+  writeText,
+  writeTextSync
+});
+//# sourceMappingURL=index.cjs.map