elit 3.5.2 → 3.5.4

package/README.md

@@ -226,6 +226,7 @@ npx elit desktop build ./src/main.ts --release
 npx elit mobile init
 npx elit mobile run android
 npx elit native generate android ./src/native-screen.ts --name HomeScreen
+npx elit pm start --script "npm start" --name my-app
 npx elit wapk pack .
 npx elit wapk run ./app.wapk
 npx elit desktop wapk run ./app.wapk
@@ -255,6 +256,15 @@ Useful flags:
 - `elit native generate android ./src/native-screen.ts --name HomeScreen --package com.example.app`
 - `elit native generate ios ./src/native-screen.ts --out ./ios/HomeScreen.swift --no-preview`
 - `elit native generate ir ./src/native-screen.ts --platform android --export screen`
+- `elit pm start --script "npm start" --name my-app --runtime node`
+- `elit pm start --script "npm start" --name my-app --watch --watch-path src --restart-policy on-failure`
+- `elit pm start ./src/worker.ts --name worker --runtime bun`
+- `elit pm start --wapk ./app.wapk --name packaged-app`
+- `elit pm start --wapk gdrive://<fileId> --name packaged-app`
+- `elit pm start --google-drive-file-id <fileId> --google-drive-token-env GOOGLE_DRIVE_ACCESS_TOKEN --name packaged-app`
+- `elit pm save`
+- `elit pm resurrect`
+- `elit pm logs my-app --lines 100`
 - `elit wapk pack . --password secret-123`
 - `elit wapk ./app.wapk --runtime node|bun|deno`
 - `elit wapk run ./app.wapk --password secret-123 --sync-interval 100 --watcher`
@@ -315,6 +325,19 @@ WAPK mode notes:
 - WAPK stays unlocked by default unless `wapk.lock.password` or `--password` is provided.
 - See [docs/wapk.md](docs/wapk.md) for the full archive guide and `examples/wapk-example` for an end-to-end sample.
 
+PM mode notes:
+
+- `elit pm start --script "npm start"`, `elit pm start --file ./app.ts`, and `elit pm start --wapk ./app.wapk` all run through the same detached process manager.
+- WAPK PM targets can also point at `gdrive://<fileId>` or use `pm.apps[].wapkRun.googleDrive` plus forwarded WAPK run flags like `syncInterval`, `watcher`, and `watchArchive`.
+- `elit pm start` boots every app from `pm.apps[]`, and `elit pm start <name>` starts one configured app by name.
+- Use `elit pm list`, `elit pm stop`, `elit pm restart`, `elit pm delete`, `elit pm save`, `elit pm resurrect`, and `elit pm logs` to manage long-running processes.
+- Use `--restart-policy always|on-failure|never` plus `--min-uptime <ms>` when you want tighter restart-loop control.
+- Use `--watch`, `--watch-path`, `--watch-ignore`, and `--watch-debounce` when the process should restart after source changes.
+- PM `--watch` and WAPK `--watcher` are different: the first restarts the managed process, the second changes how the inner WAPK runtime syncs files.
+- Use `--health-url`, `--health-grace-period`, `--health-interval`, `--health-timeout`, and `--health-max-failures` when the process exposes an HTTP health endpoint.
+- PM state and logs are stored in `./.elit/pm` by default, or in `pm.dataDir` when configured. `elit pm save` writes to `pm.dumpFile` or `./.elit/pm/dump.json`.
+- TypeScript file targets with runtime `node` require `tsx`; use `--runtime bun` when you want zero-config TypeScript execution.
+
 ## Config File
 
 Elit loads one of these files from the project root:
@@ -334,6 +357,37 @@ The config shape is:
   build?: BuildOptions | BuildOptions[];
   preview?: PreviewOptions;
   test?: TestOptions;
+  pm?: {
+    dataDir?: string;
+    apps?: Array<{
+      name: string;
+      script?: string;
+      file?: string;
+      wapk?: string;
+      wapkRun?: {
+        file?: string;
+        googleDrive?: {
+          fileId?: string;
+          accessToken?: string;
+          accessTokenEnv?: string;
+          supportsAllDrives?: boolean;
+        };
+        runtime?: 'node' | 'bun' | 'deno';
+        password?: string;
+        syncInterval?: number;
+        useWatcher?: boolean;
+        watchArchive?: boolean;
+        archiveSyncInterval?: number;
+      };
+      runtime?: 'node' | 'bun' | 'deno';
+      cwd?: string;
+      env?: Record<string, string | number | boolean>;
+      autorestart?: boolean;
+      restartDelay?: number;
+      maxRestarts?: number;
+      password?: string;
+    }>;
+  };
   mobile?: {
     cwd?: string;
     appId?: string;
@@ -479,6 +533,25 @@ export default {
       release: true,
     },
   },
+  pm: {
+    apps: [
+      {
+        name: 'api',
+        script: 'npm start',
+        runtime: 'node',
+      },
+      {
+        name: 'worker',
+        file: './src/worker.ts',
+        runtime: 'bun',
+      },
+      {
+        name: 'archive-app',
+        wapk: './dist/app.wapk',
+        runtime: 'node',
+      },
+    ],
+  },
   wapk: {
     name: 'my-app',
     version: '1.0.0',
@@ -509,6 +582,7 @@ Important details:
 - Only `VITE_` variables are exposed to client code during bundling.
 - `desktop` config provides defaults for `elit desktop`, `elit desktop run`, `elit desktop build`, and `elit desktop wapk`. Use `desktop.entry` for hybrid defaults, `desktop.native.entry` for native defaults, and `desktop.mode` to choose which one runs by default.
 - `mobile` config provides defaults for `elit mobile init|sync|open|run|build`.
+- `pm` config provides defaults for `elit pm`. Use `pm.apps[]` for named processes, `pm.dataDir` for metadata/log storage, `pm.dumpFile` for `save`/`resurrect`, and per-app restart/watch/health settings.
 - `wapk` config is loaded from `elit.config.*`, then package metadata is used as fallback.
 - `wapk.lock.password` is the config-level default for locked archives. Use `--password` when you want to supply unlock credentials at command time instead of writing them into config.
 - `wapk run` and `desktop wapk run` sync runtime file changes back into the same `.wapk` archive.
@@ -872,11 +946,12 @@ The package also exports `elit/test`, `elit/test-runtime`, and `elit/test-report
 
 Latest release notes live in [CHANGELOG.md](CHANGELOG.md).
 
-Highlights in `v3.5.2`:
+Highlights in `v3.5.4`:
 
-- Simplified WAPK locking to password-only credentials across config, CLI, and helper APIs.
-- `wapk.lock` now accepts only `password` in `elit.config.*`.
-- `elit wapk` and `elit desktop wapk` now accept only `--password` when opening locked archives.
+- Added `elit pm` for detached background process management of shell commands, file targets, and WAPK apps.
+- Added `pm.apps[]` and `pm.dataDir` in `elit.config.*` for config-first process manager workflows.
+- Added `elit pm save` / `elit pm resurrect`, `pm.dumpFile`, watch mode, health checks, and restart-policy controls for the process manager.
+- Added lifecycle commands for managed apps: `list`, `stop`, `restart`, `delete`, and `logs`.
 
 ## Good Defaults For Generated Code
 

package/dist/chokidar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chokidar.d.ts","sourceRoot":"","sources":["../src/chokidar.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAyEtC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;IAExD;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,GAAG;QAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;IAEF;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,qBAAa,SAAU,SAAQ,YAAY;IACzC,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,QAAQ,CAA0B;gBAE9B,OAAO,CAAC,EAAE,YAAY;IAK3B,OAAO,EAAE,YAAY,CAAC;IAE7B;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAkBxC;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAkB5C;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5B;;OAEG;IACH,UAAU,IAAI;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE;IAkB/C;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI;CAGhC;AAqCD;;GAEG;AACH,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EACxB,OAAO,CAAC,EAAE,YAAY,GACrB,SAAS,CAoEX;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,GAAG,KAAK,GAAG,MAAM,CAEpD;AAED;;GAEG;;;;;;AACH,wBAIE"}
+{"version":3,"file":"chokidar.d.ts","sourceRoot":"","sources":["../src/chokidar.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AA2EtC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;IAExD;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,GAAG;QAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;IAEF;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,qBAAa,SAAU,SAAQ,YAAY;IACzC,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,QAAQ,CAA0B;gBAE9B,OAAO,CAAC,EAAE,YAAY;IAK3B,OAAO,EAAE,YAAY,CAAC;IAE7B;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAkBxC;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAkB5C;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5B;;OAEG;IACH,UAAU,IAAI;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE;IAkB/C;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI;CAGhC;AA6DD;;GAEG;AACH,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EACxB,OAAO,CAAC,EAAE,YAAY,GACrB,SAAS,CAoEX;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,GAAG,KAAK,GAAG,MAAM,CAEpD;AAED;;GAEG;;;;;;AACH,wBAIE"}

package/dist/chokidar.js

@@ -34,9 +34,282 @@ var runtime = (() => {
   if (typeof Bun !== "undefined") return "bun";
   return "node";
 })();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
+// src/fs.ts
+var fs;
+var fsPromises;
+if (isNode || isBun) {
+  fs = require("fs");
+  fsPromises = require("fs/promises");
+}
+function existsSync(path) {
+  try {
+    statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function statSync(path) {
+  if (isNode || isBun) {
+    return fs.statSync(path);
+  } else if (isDeno) {
+    const info = Deno.statSync(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+function createStatsFromDenoFileInfo(info) {
+  return {
+    isFile: () => info.isFile,
+    isDirectory: () => info.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => info.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: info.dev || 0,
+    ino: info.ino || 0,
+    mode: info.mode || 0,
+    nlink: info.nlink || 1,
+    uid: info.uid || 0,
+    gid: info.gid || 0,
+    rdev: 0,
+    size: info.size,
+    blksize: info.blksize || 4096,
+    blocks: info.blocks || Math.ceil(info.size / 512),
+    atimeMs: info.atime?.getTime() || Date.now(),
+    mtimeMs: info.mtime?.getTime() || Date.now(),
+    ctimeMs: info.birthtime?.getTime() || Date.now(),
+    birthtimeMs: info.birthtime?.getTime() || Date.now(),
+    atime: info.atime || /* @__PURE__ */ new Date(),
+    mtime: info.mtime || /* @__PURE__ */ new Date(),
+    ctime: info.birthtime || /* @__PURE__ */ new Date(),
+    birthtime: info.birthtime || /* @__PURE__ */ new Date()
+  };
+}
+
+// src/path.ts
+function getSeparator(isWin) {
+  return isWin ? "\\" : "/";
+}
+function getCwd() {
+  if (isNode || isBun) {
+    return process.cwd();
+  } else if (isDeno) {
+    return Deno.cwd();
+  }
+  return "/";
+}
+function findLastSeparator(path) {
+  return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+}
+function createPathOps(isWin) {
+  return {
+    sep: getSeparator(isWin),
+    delimiter: isWin ? ";" : ":",
+    normalize: (path) => normalizePath(path, isWin),
+    join: (...paths) => joinPaths(paths, isWin),
+    resolve: (...paths) => resolvePaths(paths, isWin),
+    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+    relative: (from, to) => relativePath(from, to, isWin),
+    dirname: (path) => getDirname(path, isWin),
+    basename: (path, ext) => getBasename(path, ext, isWin),
+    extname: (path) => getExtname(path),
+    parse: (path) => parsePath(path, isWin),
+    format: (pathObject) => formatPath(pathObject, isWin)
+  };
+}
+function isAbsolutePosix(path) {
+  return path.length > 0 && path[0] === "/";
+}
+function isAbsoluteWin(path) {
+  const len = path.length;
+  if (len === 0) return false;
+  const code = path.charCodeAt(0);
+  if (code === 47 || code === 92) {
+    return true;
+  }
+  if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+    if (len > 2 && path.charCodeAt(1) === 58) {
+      const code2 = path.charCodeAt(2);
+      if (code2 === 47 || code2 === 92) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var isWindows = (() => {
+  if (isNode) {
+    return process.platform === "win32";
+  } else if (isDeno) {
+    return Deno.build.os === "windows";
+  }
+  return typeof process !== "undefined" && process.platform === "win32";
+})();
+var posix = createPathOps(false);
+var win32 = createPathOps(true);
+function normalizePath(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
+  const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
+  let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const parts = normalized.split(separator);
+  const result = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "" || part === ".") {
+      if (i === 0 && isAbsolute) result.push("");
+      continue;
+    }
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        if (!(result.length === 1 && result[0] === "")) {
+          result.pop();
+        }
+      } else if (!isAbsolute) {
+        result.push("..");
+      }
+    } else {
+      result.push(part);
+    }
+  }
+  let final = result.join(separator);
+  if (final.length === 0) {
+    return isAbsolute ? separator : ".";
+  }
+  if (trailingSeparator && final[final.length - 1] !== separator) {
+    final += separator;
+  }
+  return final;
+}
+function joinPaths(paths, isWin) {
+  if (paths.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  let joined = "";
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    if (path && path.length > 0) {
+      if (joined.length === 0) {
+        joined = path;
+      } else {
+        joined += separator + path;
+      }
+    }
+  }
+  if (joined.length === 0) return ".";
+  return normalizePath(joined, isWin);
+}
+function resolvePaths(paths, isWin) {
+  const separator = getSeparator(isWin);
+  let resolved = "";
+  let isAbsolute = false;
+  for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
+    const path = paths[i];
+    if (path && path.length > 0) {
+      resolved = path + (resolved.length > 0 ? separator + resolved : "");
+      isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+    }
+  }
+  if (!isAbsolute) {
+    const cwd = getCwd();
+    resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
+  }
+  return normalizePath(resolved, isWin);
+}
+function relativePath(from, to, isWin) {
+  from = resolvePaths([from], isWin);
+  to = resolvePaths([to], isWin);
+  if (from === to) return "";
+  const separator = getSeparator(isWin);
+  const fromParts = from.split(separator).filter((p) => p.length > 0);
+  const toParts = to.split(separator).filter((p) => p.length > 0);
+  let commonLength = 0;
+  const minLength = Math.min(fromParts.length, toParts.length);
+  for (let i = 0; i < minLength; i++) {
+    if (fromParts[i] === toParts[i]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  const upCount = fromParts.length - commonLength;
+  const result = [];
+  for (let i = 0; i < upCount; i++) {
+    result.push("..");
+  }
+  for (let i = commonLength; i < toParts.length; i++) {
+    result.push(toParts[i]);
+  }
+  return result.join(separator) || ".";
+}
+function getDirname(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const normalized = normalizePath(path, isWin);
+  const lastSepIndex = normalized.lastIndexOf(separator);
+  if (lastSepIndex === -1) return ".";
+  if (lastSepIndex === 0) return separator;
+  return normalized.slice(0, lastSepIndex);
+}
+function getBasename(path, ext, isWin) {
+  if (path.length === 0) return "";
+  const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+  let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+function getExtname(path) {
+  const lastDotIndex = path.lastIndexOf(".");
+  const lastSepIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+    return "";
+  }
+  return path.slice(lastDotIndex);
+}
+function parsePath(path, isWin) {
+  let root = "";
+  if (isWin) {
+    if (path.length >= 2 && path[1] === ":") {
+      root = path.slice(0, 2);
+      if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
+        root += "\\";
+      }
+    } else if (path[0] === "\\" || path[0] === "/") {
+      root = "\\";
+    }
+  } else {
+    if (path[0] === "/") {
+      root = "/";
+    }
+  }
+  const dir = getDirname(path, isWin);
+  const base = getBasename(path, void 0, isWin);
+  const ext = getExtname(path);
+  const name = ext ? base.slice(0, base.length - ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+function formatPath(pathObject, isWin) {
+  const separator = getSeparator(isWin);
+  const dir = pathObject.dir || pathObject.root || "";
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+  return dir + separator + base;
+}
+function dirname(path) {
+  return getDirname(path, isWindows);
+}
 
 // src/chokidar.ts
-function normalizePath(path) {
+function normalizePath2(path) {
   return path.replace(/\\/g, "/");
 }
 function emitEvent(watcher, eventType, path) {
@@ -46,22 +319,22 @@ function emitEvent(watcher, eventType, path) {
 function matchesAnyPattern(path, patterns) {
   return patterns.some((pattern) => matchesPattern(path, pattern));
 }
-function handleRenameEvent(watcher, fullPath, fs) {
+function handleRenameEvent(watcher, fullPath, fs2) {
   try {
-    fs.statSync(fullPath);
+    fs2.statSync(fullPath);
     emitEvent(watcher, "add", fullPath);
   } catch {
     emitEvent(watcher, "unlink", fullPath);
   }
 }
-function setupFsWatch(watcher, baseDir, patterns, fs) {
+function setupFsWatch(watcher, baseDir, patterns, fs2) {
   try {
-    const nativeWatcher = fs.watch(baseDir, { recursive: true }, (eventType, filename) => {
+    const nativeWatcher = fs2.watch(baseDir, { recursive: true }, (eventType, filename) => {
       if (!filename) return;
-      const fullPath = normalizePath(`${baseDir}/${filename}`);
+      const fullPath = normalizePath2(`${baseDir}/${filename}`);
       if (!matchesAnyPattern(fullPath, patterns)) return;
       if (eventType === "rename") {
-        handleRenameEvent(watcher, fullPath, fs);
+        handleRenameEvent(watcher, fullPath, fs2);
       } else if (eventType === "change") {
         emitEvent(watcher, "change", fullPath);
       }
@@ -156,20 +429,37 @@ var FSWatcher = class extends import_events.EventEmitter {
   }
 };
 function getBaseDirectory(pattern) {
-  const parts = pattern.split(/[\\\/]/);
+  const normalizedPattern = normalizePath2(pattern);
+  const parts = normalizedPattern.split(/[\\\/]/);
   let baseDir = "";
+  let sawGlob = false;
   for (const part of parts) {
     if (part.includes("*") || part.includes("?")) {
+      sawGlob = true;
       break;
     }
     baseDir = baseDir ? `${baseDir}/${part}` : part;
   }
-  return baseDir || ".";
+  if (sawGlob) {
+    return baseDir || ".";
+  }
+  if (normalizedPattern && existsSync(normalizedPattern)) {
+    try {
+      return statSync(normalizedPattern).isDirectory() ? normalizedPattern : normalizePath2(dirname(normalizedPattern)) || ".";
+    } catch {
+      return normalizePath2(dirname(normalizedPattern)) || ".";
+    }
+  }
+  const lastSegment = parts[parts.length - 1] || "";
+  if (lastSegment.includes(".") && !lastSegment.startsWith(".")) {
+    return normalizePath2(dirname(normalizedPattern)) || ".";
+  }
+  return normalizedPattern || ".";
 }
 function matchesPattern(filePath, pattern) {
-  const regexPattern = normalizePath(pattern).replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+  const regexPattern = normalizePath2(pattern).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
   const regex = new RegExp(`^${regexPattern}$`);
-  const normalizedPath = normalizePath(filePath);
+  const normalizedPath = normalizePath2(filePath);
   return regex.test(normalizedPath);
 }
 function watch(paths, options) {
@@ -184,11 +474,11 @@ function watch(paths, options) {
     watchMap.get(baseDir).push(path);
   });
   if (runtime === "node") {
-    const fs = require("fs");
-    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs));
+    const fs2 = require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
   } else if (runtime === "bun") {
-    const fs = require("fs");
-    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs));
+    const fs2 = require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
   } else if (runtime === "deno") {
     const baseDirs = Array.from(watchMap.keys());
     const allPatterns = Array.from(watchMap.values()).flat();
@@ -198,7 +488,7 @@ function watch(paths, options) {
         for await (const event of denoWatcher) {
           if (watcher["_closed"]) break;
           for (const path of event.paths) {
-            const normalizedPath = normalizePath(path);
+            const normalizedPath = normalizePath2(path);
             if (!matchesAnyPattern(normalizedPath, allPatterns)) continue;
             switch (event.kind) {
               case "create":