@seedvault/cli 0.1.0 → 0.1.2

package/dist/sv.js

@@ -0,0 +1,2705 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/commands/init.ts
+import * as readline from "readline/promises";
+import { stdin, stdout } from "process";
+
+// src/config.ts
+import { join, resolve, relative, isAbsolute } from "path";
+import { homedir } from "os";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+var CONFIG_DIR = join(homedir(), ".config", "seedvault");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+var PID_PATH = join(CONFIG_DIR, "daemon.pid");
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function getPidPath() {
+  return PID_PATH;
+}
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function configExists() {
+  return existsSync(CONFIG_PATH);
+}
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    throw new Error(`No config found. Run 'sv init' first.
+  Expected: ${CONFIG_PATH}`);
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf-8");
+  return JSON.parse(raw);
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`);
+}
+function isChildPath(parentPath, maybeChildPath) {
+  const rel = relative(parentPath, maybeChildPath);
+  if (rel === "" || rel === ".")
+    return false;
+  return !rel.startsWith("..") && !isAbsolute(rel);
+}
+function pruneOverlappingCollections(collections) {
+  const removedOverlappingCollections = [];
+  const seenPaths = new Set;
+  const deduped = [];
+  for (const collection of collections) {
+    if (seenPaths.has(collection.path)) {
+      removedOverlappingCollections.push(collection);
+      continue;
+    }
+    seenPaths.add(collection.path);
+    deduped.push(collection);
+  }
+  const kept = [];
+  for (const candidate of deduped) {
+    const hasParent = deduped.some((other) => other.path !== candidate.path && isChildPath(other.path, candidate.path));
+    if (hasParent) {
+      removedOverlappingCollections.push(candidate);
+    } else {
+      kept.push(candidate);
+    }
+  }
+  return { collections: kept, removedOverlappingCollections };
+}
+function normalizeConfigCollections(config) {
+  const { collections, removedOverlappingCollections } = pruneOverlappingCollections(config.collections);
+  if (removedOverlappingCollections.length === 0) {
+    return { config, removedOverlappingCollections: [] };
+  }
+  return {
+    config: {
+      ...config,
+      collections
+    },
+    removedOverlappingCollections
+  };
+}
+function addCollection(config, collectionPath, name) {
+  const resolved = collectionPath.startsWith("~") ? resolve(homedir(), collectionPath.slice(2)) : resolve(collectionPath);
+  if (config.collections.some((f) => f.path === resolved)) {
+    throw new Error(`Collection path '${resolved}' is already configured.`);
+  }
+  const parentConflict = config.collections.find((f) => isChildPath(f.path, resolved));
+  if (parentConflict) {
+    throw new Error(`Cannot add '${resolved}' because it is inside existing collection '${parentConflict.name}' (${parentConflict.path}).`);
+  }
+  const removedChildCollections = config.collections.filter((f) => isChildPath(resolved, f.path));
+  const retainedCollections = config.collections.filter((f) => !isChildPath(resolved, f.path));
+  if (retainedCollections.some((f) => f.name === name)) {
+    throw new Error(`A collection named '${name}' already exists. Use --name to pick a different name.`);
+  }
+  return {
+    config: {
+      ...config,
+      collections: [...retainedCollections, { path: resolved, name }]
+    },
+    removedChildCollections
+  };
+}
+function removeCollection(config, name) {
+  const filtered = config.collections.filter((f) => f.name !== name);
+  if (filtered.length === config.collections.length) {
+    throw new Error(`No collection named '${name}' found.`);
+  }
+  return { ...config, collections: filtered };
+}
+function defaultCollectionName(collectionPath) {
+  const abs = collectionPath.startsWith("~") ? join(homedir(), collectionPath.slice(1)) : collectionPath;
+  const base = abs.split("/").filter(Boolean).pop();
+  if (!base)
+    throw new Error(`Cannot derive name from path: ${collectionPath}`);
+  return base;
+}
+
+// src/client.ts
+class ApiError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+  }
+}
+function encodePath(path) {
+  return path.split("/").map(encodeURIComponent).join("/");
+}
+function createClient(serverUrl, token) {
+  const base = serverUrl.replace(/\/+$/, "");
+  async function request(method, path, opts = {}) {
+    const headers = {};
+    if (opts.auth !== false && token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (opts.contentType) {
+      headers["Content-Type"] = opts.contentType;
+    }
+    const res = await fetch(`${base}${path}`, {
+      method,
+      headers,
+      body: opts.body
+    });
+    if (!res.ok) {
+      let msg;
+      try {
+        const json = await res.json();
+        msg = json.error || res.statusText;
+      } catch {
+        msg = res.statusText;
+      }
+      throw new ApiError(res.status, msg);
+    }
+    return res;
+  }
+  return {
+    async signup(name, invite) {
+      const body = { name };
+      if (invite)
+        body.invite = invite;
+      const res = await request("POST", "/v1/signup", {
+        body: JSON.stringify(body),
+        contentType: "application/json",
+        auth: false
+      });
+      return res.json();
+    },
+    async createInvite() {
+      const res = await request("POST", "/v1/invites");
+      return res.json();
+    },
+    async listContributors() {
+      const res = await request("GET", "/v1/contributors");
+      return res.json();
+    },
+    async putFile(contributorId, path, content) {
+      const res = await request("PUT", `/v1/contributors/${contributorId}/files/${encodePath(path)}`, {
+        body: content,
+        contentType: "text/markdown"
+      });
+      return res.json();
+    },
+    async deleteFile(contributorId, path) {
+      await request("DELETE", `/v1/contributors/${contributorId}/files/${encodePath(path)}`);
+    },
+    async listFiles(contributorId, prefix) {
+      const qs = prefix ? `?prefix=${encodeURIComponent(prefix)}` : "";
+      const res = await request("GET", `/v1/contributors/${contributorId}/files${qs}`);
+      return res.json();
+    },
+    async getFile(contributorId, path) {
+      const res = await request("GET", `/v1/contributors/${contributorId}/files/${encodePath(path)}`);
+      return res.text();
+    },
+    async health() {
+      const res = await request("GET", "/health", { auth: false });
+      return res.json();
+    }
+  };
+}
+
+// src/commands/init.ts
+async function init(args) {
+  const flags = parseFlags(args);
+  if (configExists() && !flags.force) {
+    console.log("Seedvault is already configured.");
+    console.log("  Run 'sv init --force' to overwrite.");
+    return;
+  }
+  if (flags.server && flags.token) {
+    const client = createClient(flags.server, flags.token);
+    try {
+      await client.health();
+    } catch {
+      console.error(`Could not reach server at ${flags.server}`);
+      process.exit(1);
+    }
+    const contributorId = flags["contributor-id"] || "";
+    if (!contributorId) {
+      console.error("When using --token, also pass --contributor-id");
+      process.exit(1);
+    }
+    const config = {
+      server: flags.server,
+      token: flags.token,
+      contributorId,
+      collections: []
+    };
+    saveConfig(config);
+    console.log("Seedvault configured.");
+    console.log(`  Server:  ${config.server}`);
+    console.log(`  Contributor ID: ${config.contributorId}`);
+    return;
+  }
+  if (flags.server && flags.name) {
+    const client = createClient(flags.server);
+    try {
+      await client.health();
+    } catch {
+      console.error(`Could not reach server at ${flags.server}`);
+      process.exit(1);
+    }
+    const result = await client.signup(flags.name, flags.invite);
+    const config = {
+      server: flags.server,
+      token: result.token,
+      contributorId: result.contributor.id,
+      collections: []
+    };
+    saveConfig(config);
+    console.log("Signed up and configured.");
+    console.log(`  Server:  ${config.server}`);
+    console.log(`  Contributor: ${result.contributor.name} (${result.contributor.id})`);
+    console.log(`  Token:   ${result.token}`);
+    return;
+  }
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    console.log(`Seedvault Setup
+`);
+    const server = await rl.question("Server URL: ");
+    if (!server) {
+      console.error("Server URL is required.");
+      process.exit(1);
+    }
+    const client = createClient(server);
+    try {
+      await client.health();
+      console.log(`  Server is reachable.
+`);
+    } catch {
+      console.error(`  Could not reach server at ${server}`);
+      process.exit(1);
+    }
+    const hasToken = await rl.question("Do you already have a token? (y/N): ");
+    if (hasToken.toLowerCase() === "y") {
+      const token = await rl.question("Token: ");
+      const contributorId = await rl.question("Contributor ID: ");
+      const config = { server, token: token.trim(), contributorId: contributorId.trim(), collections: [] };
+      saveConfig(config);
+      console.log(`
+Seedvault configured.`);
+    } else {
+      const name = await rl.question("Contributor name (e.g. your-name-notes): ");
+      const invite = await rl.question("Invite code (leave blank if first user): ");
+      const result = await client.signup(name.trim(), invite.trim() || undefined);
+      const config = {
+        server,
+        token: result.token,
+        contributorId: result.contributor.id,
+        collections: []
+      };
+      saveConfig(config);
+      console.log(`
+Signed up as '${result.contributor.name}'.`);
+      console.log(`  Contributor ID: ${result.contributor.id}`);
+      console.log(`  Token:   ${result.token}`);
+      console.log(`
+Save your token \u2014 it won't be shown again.`);
+    }
+    console.log(`
+Next steps:`);
+    console.log("  sv add ~/notes         # Add a collection to sync");
+    console.log("  sv start               # Start the daemon");
+  } finally {
+    rl.close();
+  }
+}
+function parseFlags(args) {
+  const flags = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = "true";
+      }
+    }
+  }
+  return flags;
+}
+
+// src/commands/add.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
+async function add(args) {
+  if (args.length === 0 || args[0].startsWith("--")) {
+    console.error("Usage: sv add <path> [--name <name>]");
+    process.exit(1);
+  }
+  const rawPath = args[0];
+  const nameIdx = args.indexOf("--name");
+  const name = nameIdx !== -1 && args[nameIdx + 1] ? args[nameIdx + 1] : defaultCollectionName(rawPath);
+  const absPath = rawPath.startsWith("~") ? resolve2(homedir2(), rawPath.slice(2)) : resolve2(rawPath);
+  if (!existsSync2(absPath)) {
+    console.error(`Directory not found: ${absPath}`);
+    process.exit(1);
+  }
+  const config = loadConfig();
+  try {
+    const result = addCollection(config, absPath, name);
+    const updated = result.config;
+    saveConfig(updated);
+    console.log(`Added collection: ${absPath}`);
+    console.log(`  Name: ${name}`);
+    console.log(`  Files will sync to: ${name}/<relative-path>`);
+    if (result.removedChildCollections.length > 0) {
+      console.log("  Removed overlapping child collections:");
+      for (const child of result.removedChildCollections) {
+        console.log(`    - ${child.name} (${child.path})`);
+      }
+    }
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/remove.ts
+async function remove(args) {
+  if (args.length === 0) {
+    console.error("Usage: sv remove <name>");
+    process.exit(1);
+  }
+  const name = args[0];
+  const config = loadConfig();
+  try {
+    const updated = removeCollection(config, name);
+    saveConfig(updated);
+    console.log(`Removed collection '${name}'.`);
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/collections.ts
+async function collections() {
+  const config = loadConfig();
+  if (config.collections.length === 0) {
+    console.log("No collections configured.");
+    console.log("  Run 'sv add <path>' to add one.");
+    return;
+  }
+  console.log(`Configured collections:
+`);
+  for (const f of config.collections) {
+    console.log(`  ${f.name}`);
+    console.log(`    Path:   ${f.path}`);
+    console.log(`    Syncs:  ${f.name}/<relative-path>`);
+    console.log();
+  }
+}
+
+// src/commands/start.ts
+import { writeFileSync as writeFileSync2, unlinkSync } from "fs";
+
+// ../node_modules/.bun/chokidar@4.0.3/node_modules/chokidar/esm/index.js
+import { stat as statcb } from "fs";
+import { stat as stat3, readdir as readdir2 } from "fs/promises";
+import { EventEmitter } from "events";
+import * as sysPath2 from "path";
+
+// ../node_modules/.bun/readdirp@4.1.2/node_modules/readdirp/esm/index.js
+import { stat, lstat, readdir, realpath } from "fs/promises";
+import { Readable } from "stream";
+import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "path";
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES = new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === undefined)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+
+class ReaddirpStream extends Readable {
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat : stat;
+    if (wantBigintFsStats) {
+      this._stat = (path) => statMethod(path, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth ?? defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = presolve(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = undefined;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path, depth) {
+    let files;
+    try {
+      files = await readdir(path, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path };
+  }
+  async _formatEntry(dirent, path) {
+    let entry;
+    const basename = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = presolve(pjoin(path, basename));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+}
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+
+// ../node_modules/.bun/chokidar@4.0.3/node_modules/chokidar/esm/handler.js
+import { watchFile, unwatchFile, watch as fs_watch } from "fs";
+import { open, stat as stat2, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
+import * as sysPath from "path";
+import { type as osType } from "os";
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {};
+var pl = process.platform;
+var isWindows = pl === "win32";
+var isMacos = pl === "darwin";
+var isLinux = pl === "linux";
+var isFreeBSD = pl === "freebsd";
+var isIBMi = osType() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: lstat2, stat: stat2 };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+var addAndConvert = (main, prop, item) => {
+  let container = main[prop];
+  if (!(container instanceof Set)) {
+    main[prop] = container = new Set([container]);
+  }
+  container.add(item);
+};
+var clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+var delFromSet = (main, prop, item) => {
+  const container = main[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main[prop];
+  }
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = new Map;
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path);
+    emitRaw(rawEvent, evPath, { watchedPath: path });
+    if (evPath && path !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+    }
+  };
+  try {
+    return fs_watch(path, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return;
+  }
+}
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path, fullPath, options, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {}
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = new Map;
+var setFsWatchFileListener = (path, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    unwatchFile(fullPath);
+    cont = undefined;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+
+class NodeFsHandler {
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  _watchWithNodeFs(path, listener) {
+    const opts = this.fsw.options;
+    const directory = sysPath.dirname(path);
+    const basename2 = sysPath.basename(path);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename2);
+    const absolutePath = sysPath.resolve(path);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename2) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname2 = sysPath.dirname(file);
+    const basename2 = sysPath.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname2);
+    let prevStats = stats;
+    if (parent.has(basename2))
+      return;
+    const listener = async (path, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat2(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname2, basename2);
+        }
+      } else if (parent.has(basename2)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  async _handleSymlink(entry, directory, path, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path);
+      } catch (e) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sysPath.join(directory, "");
+    throttler = this.fsw._throttle("readdir", directory, 1000);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = new Set;
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = undefined;
+        return;
+      }
+      const item = entry.path;
+      let path = sysPath.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = undefined;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path = sysPath.join(dir, sysPath.relative(dir, path));
+        this._addToNodeFs(path, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve4, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = undefined;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve4(undefined);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = undefined;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+    const tracked = parentDir.has(sysPath.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sysPath.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sysPath.resolve(path);
+        const targetPath = follow ? await fsrealpath(path) : path;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== undefined) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path) : path;
+        if (this.fsw.closed)
+          return;
+        const parent = sysPath.dirname(wh.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh.watchPath);
+        this.fsw._emit(EV.ADD, wh.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== undefined) {
+          this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path;
+      }
+    }
+  }
+}
+
+// ../node_modules/.bun/chokidar@4.0.3/node_modules/chokidar/esm/index.js
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative4 = sysPath2.relative(matcher.path, string);
+        if (!relative4) {
+          return false;
+        }
+        return !relative4.startsWith("..") && !sysPath2.isAbsolute(relative4);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path) {
+  if (typeof path !== "string")
+    throw new Error("string expected");
+  path = sysPath2.normalize(path);
+  path = path.replace(/\\/g, "/");
+  let prepend = false;
+  if (path.startsWith("//"))
+    prepend = true;
+  const DOUBLE_SLASH_RE2 = /\/\//;
+  while (path.match(DOUBLE_SLASH_RE2))
+    path = path.replace(DOUBLE_SLASH_RE2, "/");
+  if (prepend)
+    path = "/" + path;
+  return path;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path = normalizePath(testString);
+  for (let index = 0;index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  while (str.match(DOUBLE_SLASH_RE)) {
+    str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  }
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path) => toUnix(sysPath2.normalize(toUnix(path)));
+var normalizeIgnored = (cwd = "") => (path) => {
+  if (typeof path === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path) ? path : sysPath2.join(cwd, path));
+  } else {
+    return path;
+  }
+};
+var getAbsolutePath = (path, cwd) => {
+  if (sysPath2.isAbsolute(path)) {
+    return path;
+  }
+  return sysPath2.join(cwd, path);
+};
+var EMPTY_SET = Object.freeze(new Set);
+
+class DirEntry {
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = new Set;
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir2(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+}
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+
+class WatchHelper {
+  constructor(path, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path;
+    this.path = path = path.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sysPath2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+}
+
+class FSWatcher extends EventEmitter {
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = new Map;
+    this._ignoredPaths = new Set;
+    this._throttled = new Map;
+    this._streams = new Set;
+    this._symlinkPaths = new Map;
+    this._watched = new Map;
+    this._pendingWrites = new Map;
+    this._pendingUnlinks = new Map;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 };
+    const opts = {
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      atomic: true,
+      ..._opts,
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === undefined)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== undefined) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = undefined;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path) => {
+        const absPath = getAbsolutePath(path, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path) => {
+      this._removeIgnoredPath(path);
+    });
+    this._userIgnored = undefined;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, undefined, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path) => {
+      if (!sysPath2.isAbsolute(path) && !this._closers.has(path)) {
+        if (cwd)
+          path = sysPath2.join(cwd, path);
+        path = sysPath2.resolve(path);
+      }
+      this._closePath(path);
+      this._addIgnoredPath(path);
+      if (this._watched.has(path)) {
+        this._addIgnoredPath({
+          path,
+          recursive: true
+        });
+      }
+      this._userIgnored = undefined;
+    });
+    return this;
+  }
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise = closer();
+      if (promise instanceof Promise)
+        closers.push(promise);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = undefined;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => {
+      return;
+    }) : Promise.resolve();
+    return this._closePromise;
+  }
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
+      const index = key || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  async _emit(event, path, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows)
+      path = sysPath2.normalize(path);
+    if (opts.cwd)
+      path = sysPath2.relative(opts.cwd, path);
+    const args = [path];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path))) {
+      pw.lastChange = new Date;
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path2) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path2);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path, 50);
+      if (isThrottled)
+        return this;
+    }
+    if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path) : path;
+      let stats2;
+      try {
+        stats2 = await stat3(fullPath);
+      } catch (err) {}
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  _handleError(error) {
+    const code = error && error.code;
+    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error);
+    }
+    return error || this.closed;
+  }
+  _throttle(actionType, path, timeout) {
+    if (!this._throttled.has(actionType)) {
+      this._throttled.set(actionType, new Map);
+    }
+    const action = this._throttled.get(actionType);
+    if (!action)
+      throw new Error("invalid throttle");
+    const actionPath = action.get(path);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path);
+      const count = item ? item.count : 0;
+      action.delete(path);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count;
+    };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  _awaitWriteFinish(path, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path;
+    if (this.options.cwd && !sysPath2.isAbsolute(path)) {
+      fullPath = sysPath2.join(this.options.cwd, path);
+    }
+    const now = new Date;
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      statcb(fullPath, (err, curStat) => {
+        if (err || !writes.has(path)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(new Date);
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path).lastChange = now2;
+        }
+        const pw = writes.get(path);
+        const df = now2 - pw.lastChange;
+        if (df >= threshold) {
+          writes.delete(path);
+          awfEmit(undefined, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path)) {
+      writes.set(path, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  _isIgnored(path, stats) {
+    if (this.options.atomic && DOT_RE.test(path))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list, undefined);
+    }
+    return this._userIgnored(path, stats);
+  }
+  _isntIgnored(path, stat4) {
+    return !this._isIgnored(path, stat4);
+  }
+  _getWatchHelpers(path) {
+    return new WatchHelper(path, this.options.followSymlinks, this);
+  }
+  _getWatchedDir(directory) {
+    const dir = sysPath2.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  _remove(directory, item, isDirectory) {
+    const path = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path, 100))
+      return;
+    if (!isDirectory && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp = this._getWatchedDir(path);
+    const nestedDirectoryChildren = wp.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));
+    const parent = this._getWatchedDir(directory);
+    const wasTracked = parent.has(item);
+    parent.remove(item);
+    if (this._symlinkPaths.has(fullPath)) {
+      this._symlinkPaths.delete(fullPath);
+    }
+    let relPath = path;
+    if (this.options.cwd)
+      relPath = sysPath2.relative(this.options.cwd, path);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path))
+      this._emit(eventName, path);
+    this._closePath(path);
+  }
+  _closePath(path) {
+    this._closeFile(path);
+    const dir = sysPath2.dirname(path);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path));
+  }
+  _closeFile(path) {
+    const closers = this._closers.get(path);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path);
+  }
+  _addPathCloser(path, closer) {
+    if (!closer)
+      return;
+    let list = this._closers.get(path);
+    if (!list) {
+      list = [];
+      this._closers.set(path, list);
+    }
+    list.push(closer);
+  }
+  _readdirp(root, opts) {
+    if (this.closed)
+      return;
+    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root, options);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = undefined;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = undefined;
+      }
+    });
+    return stream;
+  }
+}
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+
+// src/daemon/watcher.ts
+import { relative as relative4 } from "path";
+function createWatcher(collections2, onEvent) {
+  const paths = collections2.map((f) => f.path);
+  const watcher = watch(paths, {
+    ignored: [
+      /(^|[/\\])\./,
+      "**/node_modules/**",
+      "**/*.tmp.*"
+    ],
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 300,
+      pollInterval: 100
+    }
+  });
+  const collectionMap = new Map;
+  for (const f of collections2) {
+    collectionMap.set(f.path, f.name);
+  }
+  function toServerPath(localPath) {
+    if (!localPath.endsWith(".md"))
+      return null;
+    for (const [collectionPath, name] of collectionMap) {
+      if (localPath.startsWith(collectionPath + "/") || localPath === collectionPath) {
+        const rel = relative4(collectionPath, localPath);
+        return `${name}/${rel}`;
+      }
+    }
+    return null;
+  }
+  watcher.on("add", (path) => {
+    const sp = toServerPath(path);
+    if (sp)
+      onEvent({ type: "add", serverPath: sp, localPath: path });
+  });
+  watcher.on("change", (path) => {
+    const sp = toServerPath(path);
+    if (sp)
+      onEvent({ type: "change", serverPath: sp, localPath: path });
+  });
+  watcher.on("unlink", (path) => {
+    const sp = toServerPath(path);
+    if (sp)
+      onEvent({ type: "unlink", serverPath: sp, localPath: path });
+  });
+  return watcher;
+}
+
+// src/daemon/syncer.ts
+import { readdir as readdir3, stat as stat4, readFile } from "fs/promises";
+import { join as join4, relative as relative5 } from "path";
+
+// src/daemon/queue.ts
+var MIN_BACKOFF = 1000;
+var MAX_BACKOFF = 60000;
+
+class RetryQueue {
+  items = [];
+  flushing = false;
+  backoff = MIN_BACKOFF;
+  flushTimer = null;
+  client;
+  onStatus;
+  constructor(client, onStatus = () => {}) {
+    this.client = client;
+    this.onStatus = onStatus;
+  }
+  enqueue(op) {
+    this.items.push(op);
+    this.scheduleFlush(0);
+  }
+  get pending() {
+    return this.items.length;
+  }
+  stop() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  scheduleFlush(delayMs) {
+    if (this.flushing || this.flushTimer)
+      return;
+    if (this.items.length === 0)
+      return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flush();
+    }, delayMs);
+  }
+  async flush() {
+    if (this.flushing || this.items.length === 0)
+      return;
+    this.flushing = true;
+    while (this.items.length > 0) {
+      const op = this.items[0];
+      try {
+        if (op.type === "put" && op.content !== null) {
+          await this.client.putFile(op.contributorId, op.serverPath, op.content);
+        } else if (op.type === "delete") {
+          await this.client.deleteFile(op.contributorId, op.serverPath);
+        }
+        this.items.shift();
+        this.backoff = MIN_BACKOFF;
+      } catch (e) {
+        if (e instanceof ApiError && e.status >= 400 && e.status < 500) {
+          this.onStatus(`Dropping failed op: ${op.type} ${op.serverPath} (${e.status})`);
+          this.items.shift();
+          continue;
+        }
+        const errMsg = e instanceof Error ? e.message : String(e);
+        this.onStatus(`Server unreachable (${errMsg}), ${this.items.length} op(s) queued. Retry in ${this.backoff / 1000}s.`);
+        this.flushing = false;
+        this.scheduleFlush(this.backoff);
+        this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF);
+        return;
+      }
+    }
+    this.flushing = false;
+    if (this.items.length === 0) {
+      this.onStatus("Queue flushed \u2014 all synced.");
+    }
+  }
+}
+
+// src/daemon/syncer.ts
+class Syncer {
+  client;
+  contributorId;
+  collections;
+  queue;
+  log;
+  constructor(opts) {
+    this.client = opts.client;
+    this.contributorId = opts.contributorId;
+    this.collections = opts.collections;
+    this.log = opts.onLog;
+    this.queue = new RetryQueue(opts.client, opts.onLog);
+  }
+  setCollections(collections2) {
+    this.collections = [...collections2];
+  }
+  async initialSync() {
+    let uploaded = 0;
+    let skipped = 0;
+    let deleted = 0;
+    for (const collection of [...this.collections]) {
+      const result = await this.syncCollection(collection);
+      uploaded += result.uploaded;
+      skipped += result.skipped;
+      deleted += result.deleted;
+    }
+    return { uploaded, skipped, deleted };
+  }
+  async syncCollection(collection) {
+    let uploaded = 0;
+    let skipped = 0;
+    let deleted = 0;
+    this.log(`Syncing '${collection.name}' (${collection.path})...`);
+    try {
+      const { files: serverFiles } = await this.client.listFiles(this.contributorId, collection.name + "/");
+      const serverMap = new Map;
+      for (const f of serverFiles) {
+        serverMap.set(f.path, f.modifiedAt);
+      }
+      const localFiles = await walkMd(collection.path);
+      const localServerPaths = new Set;
+      for (const localFile of localFiles) {
+        const relPath = toPosixPath(relative5(collection.path, localFile.path));
+        const serverPath = `${collection.name}/${relPath}`;
+        localServerPaths.add(serverPath);
+        const serverMod = serverMap.get(serverPath);
+        if (serverMod) {
+          const serverDate = new Date(serverMod).getTime();
+          const localDate = localFile.mtimeMs;
+          if (localDate <= serverDate) {
+            skipped++;
+            continue;
+          }
+        }
+        const content = await readFile(localFile.path, "utf-8");
+        try {
+          await this.client.putFile(this.contributorId, serverPath, content);
+          uploaded++;
+        } catch {
+          this.queue.enqueue({
+            type: "put",
+            contributorId: this.contributorId,
+            serverPath,
+            content,
+            queuedAt: new Date().toISOString()
+          });
+        }
+      }
+      for (const f of serverFiles) {
+        if (localServerPaths.has(f.path))
+          continue;
+        try {
+          await this.client.deleteFile(this.contributorId, f.path);
+          deleted++;
+        } catch {
+          this.queue.enqueue({
+            type: "delete",
+            contributorId: this.contributorId,
+            serverPath: f.path,
+            content: null,
+            queuedAt: new Date().toISOString()
+          });
+        }
+      }
+      this.log(`  '${collection.name}': ${uploaded} uploaded, ${skipped} up-to-date, ${deleted} deleted`);
+    } catch (e) {
+      this.log(`  '${collection.name}': sync failed (${e.message})`);
+    }
+    return { uploaded, skipped, deleted };
+  }
+  async purgeCollection(collection) {
+    let deleted = 0;
+    let queued = 0;
+    this.log(`Removing '${collection.name}' files from server...`);
+    try {
+      const { files: serverFiles } = await this.client.listFiles(this.contributorId, collection.name + "/");
+      for (const f of serverFiles) {
+        try {
+          await this.client.deleteFile(this.contributorId, f.path);
+          deleted++;
+        } catch {
+          this.queue.enqueue({
+            type: "delete",
+            contributorId: this.contributorId,
+            serverPath: f.path,
+            content: null,
+            queuedAt: new Date().toISOString()
+          });
+          queued++;
+        }
+      }
+      this.log(`  '${collection.name}': ${deleted} deleted, ${queued} queued`);
+    } catch (e) {
+      this.log(`  '${collection.name}': remove failed (${e.message})`);
+    }
+    return { deleted, queued };
+  }
+  async handleEvent(event) {
+    if (event.type === "add" || event.type === "change") {
+      const content = await readFile(event.localPath, "utf-8");
+      this.log(`PUT ${event.serverPath} (${content.length} bytes)`);
+      this.queue.enqueue({
+        type: "put",
+        contributorId: this.contributorId,
+        serverPath: event.serverPath,
+        content,
+        queuedAt: new Date().toISOString()
+      });
+    } else if (event.type === "unlink") {
+      this.log(`DELETE ${event.serverPath}`);
+      this.queue.enqueue({
+        type: "delete",
+        contributorId: this.contributorId,
+        serverPath: event.serverPath,
+        content: null,
+        queuedAt: new Date().toISOString()
+      });
+    }
+  }
+  stop() {
+    this.queue.stop();
+  }
+  get pendingOps() {
+    return this.queue.pending;
+  }
+}
+function toPosixPath(path) {
+  return path.split("\\").join("/");
+}
+async function walkMd(dir) {
+  const results = [];
+  await walkDirRecursive(dir, results);
+  return results;
+}
+async function walkDirRecursive(dir, results) {
+  const entries = await readdir3(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules")
+      continue;
+    const full = join4(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDirRecursive(full, results);
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      const s = await stat4(full);
+      results.push({ path: full, mtimeMs: s.mtimeMs });
+    }
+  }
+}
+
+// src/commands/start.ts
+async function start(args) {
+  const daemonize = args.includes("-d") || args.includes("--daemon");
+  if (daemonize) {
+    return startBackground();
+  }
+  return startForeground();
+}
+async function startForeground() {
+  let config = loadConfig();
+  let { config: normalizedConfig, removedOverlappingCollections } = normalizeConfigCollections(config);
+  if (removedOverlappingCollections.length > 0) {
+    config = normalizedConfig;
+  }
+  const client = createClient(config.server, config.token);
+  try {
+    await client.health();
+  } catch {
+    console.error(`Cannot reach server at ${config.server}`);
+    process.exit(1);
+  }
+  const log = (msg) => {
+    const ts = new Date().toISOString().slice(11, 19);
+    console.log(`[${ts}] ${msg}`);
+  };
+  let lastOverlapWarning = "";
+  const maybeLogOverlapWarning = (removed) => {
+    const summary = removed.map((c) => `${c.name} (${c.path})`).sort().join(", ");
+    if (!summary) {
+      lastOverlapWarning = "";
+      return;
+    }
+    if (summary === lastOverlapWarning)
+      return;
+    lastOverlapWarning = summary;
+    log(`Ignoring overlapping collections in config: ${summary}`);
+  };
+  maybeLogOverlapWarning(removedOverlappingCollections);
+  log("Seedvault daemon starting...");
+  log(`  Server:  ${config.server}`);
+  log(`  Contributor: ${config.contributorId}`);
+  if (config.collections.length === 0) {
+    log("  Collections: none");
+    log("  Waiting for collections to be added...");
+  } else {
+    log(`  Collections: ${config.collections.map((f) => f.name).join(", ")}`);
+  }
+  writeFileSync2(getPidPath(), String(process.pid));
+  const syncer = new Syncer({
+    client,
+    contributorId: config.contributorId,
+    collections: config.collections,
+    onLog: log
+  });
+  if (config.collections.length > 0) {
+    log("Running initial sync...");
+    try {
+      const { uploaded, skipped, deleted } = await syncer.initialSync();
+      log(`Initial sync complete: ${uploaded} uploaded, ${skipped} skipped, ${deleted} deleted`);
+    } catch (e) {
+      log(`Initial sync failed: ${e.message}`);
+      log("Will continue watching for changes...");
+    }
+  }
+  const onWatcherEvent = (event) => {
+    syncer.handleEvent(event).catch((e) => {
+      log(`Error handling ${event.type} for ${event.serverPath}: ${e.message}`);
+    });
+  };
+  let watcher = null;
+  const rebuildWatcher = async (collections2) => {
+    if (watcher) {
+      await watcher.close();
+      watcher = null;
+    }
+    if (collections2.length === 0) {
+      log("No collections configured. Daemon idle.");
+      return;
+    }
+    watcher = createWatcher(collections2, onWatcherEvent);
+    log(`Watching ${collections2.length} collection(s): ${collections2.map((f) => f.name).join(", ")}`);
+  };
+  await rebuildWatcher(config.collections);
+  let reloadingCollections = false;
+  const pollTimer = setInterval(() => {
+    if (reloadingCollections)
+      return;
+    let nextConfig;
+    try {
+      nextConfig = loadConfig();
+    } catch (e) {
+      log(`Failed to read config: ${e.message}`);
+      return;
+    }
+    ({ config: normalizedConfig, removedOverlappingCollections } = normalizeConfigCollections(nextConfig));
+    maybeLogOverlapWarning(removedOverlappingCollections);
+    reloadingCollections = true;
+    (async () => {
+      try {
+        const { nextConfig: reconciledConfig, added, removed } = reconcileCollections(config, normalizedConfig);
+        if (added.length === 0 && removed.length === 0)
+          return;
+        log(`Collections changed: +${added.map((c) => c.name).join(", ") || "none"}, -${removed.map((c) => c.name).join(", ") || "none"}`);
+        config = reconciledConfig;
+        syncer.setCollections(reconciledConfig.collections);
+        await rebuildWatcher(reconciledConfig.collections);
+        for (const collection of removed) {
+          await syncer.purgeCollection(collection);
+        }
+        for (const collection of added) {
+          await syncer.syncCollection(collection);
+        }
+      } catch (e) {
+        log(`Failed to reload collections from config: ${e.message}`);
+      } finally {
+        reloadingCollections = false;
+      }
+    })();
+  }, 1500);
+  log("Daemon running. Press Ctrl+C to stop.");
+  const shutdown = () => {
+    log("Shutting down...");
+    clearInterval(pollTimer);
+    if (watcher)
+      watcher.close();
+    syncer.stop();
+    try {
+      unlinkSync(getPidPath());
+    } catch {}
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+async function startBackground() {
+  loadConfig();
+  const entryPoint = import.meta.dir + "/../index.ts";
+  const logPath = getConfigDir() + "/daemon.log";
+  const child = Bun.spawn({
+    cmd: ["bun", "run", entryPoint, "start"],
+    stdin: "ignore",
+    stdout: Bun.file(logPath),
+    stderr: Bun.file(logPath),
+    env: { ...process.env }
+  });
+  const pid = child.pid;
+  writeFileSync2(getPidPath(), String(pid));
+  console.log(`Daemon started in background (PID ${pid}).`);
+  console.log(`  Log:  ${logPath}`);
+  console.log(`  Run 'sv status' to check, 'sv stop' to stop.`);
+  child.unref();
+}
+function keyByName(collections2) {
+  const map = new Map;
+  for (const collection of collections2) {
+    map.set(collection.name, collection);
+  }
+  return map;
+}
+function reconcileCollections(prev, next) {
+  const prevByName = keyByName(prev.collections);
+  const nextByName = keyByName(next.collections);
+  const added = [];
+  const removed = [];
+  for (const [name, prevCollection] of prevByName) {
+    const nextCollection = nextByName.get(name);
+    if (!nextCollection) {
+      removed.push(prevCollection);
+      continue;
+    }
+    if (nextCollection.path !== prevCollection.path) {
+      removed.push(prevCollection);
+      added.push(nextCollection);
+    }
+  }
+  for (const [name, nextCollection] of nextByName) {
+    if (!prevByName.has(name)) {
+      added.push(nextCollection);
+    }
+  }
+  return { nextConfig: next, added, removed };
+}
+
+// src/commands/stop.ts
+import { readFileSync as readFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync3 } from "fs";
+async function stop() {
+  const pidPath = getPidPath();
+  if (!existsSync3(pidPath)) {
+    console.log("No daemon is running (no PID file found).");
+    return;
+  }
+  const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
+  if (isNaN(pid)) {
+    console.error("Invalid PID file. Removing it.");
+    unlinkSync2(pidPath);
+    return;
+  }
+  try {
+    process.kill(pid, 0);
+  } catch {
+    console.log(`Daemon (PID ${pid}) is not running. Cleaning up PID file.`);
+    unlinkSync2(pidPath);
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(`Sent SIGTERM to daemon (PID ${pid}).`);
+    await Bun.sleep(500);
+    try {
+      process.kill(pid, 0);
+      console.log("Daemon still running. Send SIGKILL with: kill -9 " + pid);
+    } catch {
+      console.log("Daemon stopped.");
+      try {
+        unlinkSync2(pidPath);
+      } catch {}
+    }
+  } catch (e) {
+    console.error(`Failed to stop daemon: ${e.message}`);
+  }
+}
+
+// src/commands/status.ts
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+async function status() {
+  if (!configExists()) {
+    console.log("Not configured. Run 'sv init' first.");
+    return;
+  }
+  const config = loadConfig();
+  console.log(`Seedvault Status
+`);
+  console.log(`  Server:  ${config.server}`);
+  console.log(`  Contributor: ${config.contributorId}`);
+  const pidPath = getPidPath();
+  if (existsSync4(pidPath)) {
+    const pid = parseInt(readFileSync3(pidPath, "utf-8").trim(), 10);
+    let alive = false;
+    try {
+      process.kill(pid, 0);
+      alive = true;
+    } catch {}
+    if (alive) {
+      console.log(`  Daemon:  running (PID ${pid})`);
+    } else {
+      console.log(`  Daemon:  not running (stale PID file)`);
+    }
+  } else {
+    console.log("  Daemon:  not running");
+  }
+  if (config.collections.length === 0) {
+    console.log("  Collections: none configured");
+  } else {
+    console.log(`  Collections: ${config.collections.length}`);
+    for (const f of config.collections) {
+      console.log(`    - ${f.name} -> ${f.path}`);
+    }
+  }
+  const client = createClient(config.server, config.token);
+  try {
+    await client.health();
+    console.log("  Server:  reachable");
+  } catch {
+    console.log("  Server:  unreachable");
+  }
+  console.log();
+}
+
+// src/commands/ls.ts
+async function ls(args) {
+  const config = loadConfig();
+  const client = createClient(config.server, config.token);
+  const prefix = args[0] || undefined;
+  const { files } = await client.listFiles(config.contributorId, prefix);
+  if (files.length === 0) {
+    console.log(prefix ? `No files matching '${prefix}'.` : "No files in your contributor.");
+    return;
+  }
+  const maxPath = Math.max(...files.map((f) => f.path.length));
+  for (const f of files) {
+    const size = formatSize(f.size);
+    const date = new Date(f.modifiedAt).toLocaleString();
+    console.log(`  ${f.path.padEnd(maxPath + 2)} ${size.padStart(8)}  ${date}`);
+  }
+  console.log(`
+${files.length} file(s)`);
+}
+function formatSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/commands/cat.ts
+async function cat(args) {
+  if (args.length === 0) {
+    console.error("Usage: sv cat <path>");
+    process.exit(1);
+  }
+  const filePath = args[0];
+  const config = loadConfig();
+  const client = createClient(config.server, config.token);
+  try {
+    const content = await client.getFile(config.contributorId, filePath);
+    process.stdout.write(content);
+  } catch (e) {
+    if (e instanceof ApiError && e.status === 404) {
+      console.error(`File not found: ${filePath}`);
+      process.exit(1);
+    }
+    throw e;
+  }
+}
+
+// src/commands/contributors.ts
+async function contributors() {
+  const config = loadConfig();
+  const client = createClient(config.server, config.token);
+  const { contributors: contributors2 } = await client.listContributors();
+  if (contributors2.length === 0) {
+    console.log("No contributors in the vault.");
+    return;
+  }
+  console.log(`Contributors:
+`);
+  for (const contributor of contributors2) {
+    const you = contributor.id === config.contributorId ? " (you)" : "";
+    console.log(`  ${contributor.name}${you}`);
+    console.log(`    ID:      ${contributor.id}`);
+    console.log(`    Created: ${new Date(contributor.createdAt).toLocaleString()}`);
+    console.log();
+  }
+}
+
+// src/commands/invite.ts
+async function invite() {
+  const config = loadConfig();
+  const client = createClient(config.server, config.token);
+  try {
+    const result = await client.createInvite();
+    console.log(`Invite code: ${result.invite}`);
+    console.log(`
+Share this with the person you want to invite.`);
+    console.log(`They can sign up with:`);
+    console.log(`  sv init --server ${config.server} --name <name> --invite ${result.invite}`);
+  } catch (e) {
+    if (e instanceof ApiError && e.status === 403) {
+      console.error("Only the operator can generate invite codes.");
+      process.exit(1);
+    }
+    throw e;
+  }
+}
+
+// src/index.ts
+var USAGE = `
+Seedvault CLI
+
+Usage: sv <command> [options]
+
+Setup:
+  init                          Interactive first-time setup
+  init --server URL --token T   Non-interactive (existing token)
+  init --server URL --name N    Non-interactive (signup)
+
+Collections:
+  add <path> [--name N]         Add a collection path
+  remove <name>                 Remove a collection by name
+  collections                   List configured collections
+
+Daemon:
+  start                         Start syncing (foreground)
+  start -d                      Start syncing (background)
+  stop                          Stop the daemon
+  status                        Show sync status
+
+Files:
+  ls [prefix]                   List files in your contributor
+  cat <path>                    Read a file from the server
+
+Vault:
+  contributors                  List all contributors
+  invite                        Generate an invite code (operator only)
+`.trim();
+async function main() {
+  const [cmd, ...args] = process.argv.slice(2);
+  if (!cmd || cmd === "--help" || cmd === "-h") {
+    console.log(USAGE);
+    return;
+  }
+  if (cmd === "--version" || cmd === "-v") {
+    console.log("0.1.2");
+    return;
+  }
+  try {
+    switch (cmd) {
+      case "init":
+        return await init(args);
+      case "add":
+        return await add(args);
+      case "remove":
+        return await remove(args);
+      case "collections":
+        return await collections();
+      case "start":
+        return await start(args);
+      case "stop":
+        return await stop();
+      case "status":
+        return await status();
+      case "ls":
+        return await ls(args);
+      case "cat":
+        return await cat(args);
+      case "contributors":
+        return await contributors();
+      case "invite":
+        return await invite();
+      default:
+        console.error(`Unknown command: ${cmd}
+`);
+        console.log(USAGE);
+        process.exit(1);
+    }
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+main();