@zergai/zergbox-client 0.1.0

package/dist/sync.js

@@ -0,0 +1,1946 @@
+import {
+  DEFAULT_IGNORE_PATTERNS,
+  MERGE_CANDIDATE_STATES,
+  SYNC_CHANGE_TYPES,
+  SYNC_NODE_TYPES,
+  ZergBoxDesktopClient,
+  ZergBoxSyncConflictError,
+  fetchRemoteTree,
+  isMergeCandidate,
+  isSafeSyncPath,
+  isSyncChange,
+  isSyncNode,
+  isSyncPathIgnored,
+  normalizeSyncPath,
+  planSync,
+  remoteFileFingerprint
+} from "./chunk-KLBU4HNA.js";
+
+// src/sync.mjs
+import { watch as watchFileSystem } from "node:fs";
+import fs7 from "node:fs/promises";
+import path8 from "node:path";
+
+// ../desktop/src/control.mjs
+import { execFile } from "node:child_process";
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+import { promisify } from "node:util";
+
+// ../desktop/src/json-store.mjs
+import fs from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+function makeCorruptBackupPath(filePath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `${filePath}.corrupt-${timestamp}-${randomUUID()}`;
+}
+async function readJsonFile(filePath, fallback, options = {}) {
+  let rawJson;
+  await assertSafeJsonPath(filePath, options);
+  try {
+    rawJson = await fs.readFile(filePath, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return fallback;
+    }
+    throw error;
+  }
+  try {
+    return JSON.parse(rawJson);
+  } catch (error) {
+    if (error instanceof SyntaxError && (options.fallbackInvalidJson || options.recoverInvalidJson)) {
+      let backupPath = null;
+      if (options.recoverInvalidJson) {
+        backupPath = makeCorruptBackupPath(filePath);
+        await assertSafeJsonPath(filePath, options);
+        await fs.rename(filePath, backupPath);
+      }
+      if (typeof options.onInvalidJson === "function") {
+        options.onInvalidJson({ filePath, backupPath, error });
+      }
+      return fallback;
+    }
+    throw error;
+  }
+}
+async function writeJsonFile(filePath, value, options = {}) {
+  const mode = 384;
+  const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  await assertSafeJsonPath(filePath, options);
+  await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 448 });
+  await assertSafeJsonPath(filePath, options);
+  try {
+    await assertSafeJsonPath(filePath, options);
+    await fs.writeFile(tempPath, `${JSON.stringify(value, null, 2)}
+`, { mode });
+    await assertSafeJsonPath(filePath, options);
+    await fs.rename(tempPath, filePath);
+    await assertSafeJsonPath(filePath, options);
+    await fs.chmod(filePath, mode);
+  } catch (error) {
+    await fs.rm(tempPath, { force: true });
+    throw error;
+  }
+}
+async function assertSafeJsonPath(filePath, options) {
+  if (typeof options.assertSafePath === "function") {
+    await options.assertSafePath(filePath);
+  }
+}
+
+// ../desktop/src/control.mjs
+var CONTROL_DIR = ".zergbox-desktop";
+var PAUSE_FILE = "paused.json";
+var INVALID_PAUSE_REASON = "Pause marker is invalid; resume sync to clear it";
+var execFileAsync = promisify(execFile);
+function getPausePath(localRoot) {
+  return path2.join(localRoot, CONTROL_DIR, PAUSE_FILE);
+}
+async function pauseDesktopSync({ localRoot, reason = "Paused by user" }) {
+  const pausePath = getPausePath(localRoot);
+  const pausedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeJsonFile(pausePath, { pausedAt, reason });
+  return {
+    paused: true,
+    pausePath,
+    pausedAt,
+    pauseReason: reason
+  };
+}
+async function resumeDesktopSync({ localRoot }) {
+  const pausePath = getPausePath(localRoot);
+  await fs2.rm(pausePath, { force: true });
+  return getDesktopRuntimeStatus({ localRoot });
+}
+async function getDesktopRuntimeStatus({ localRoot }) {
+  const pausePath = getPausePath(localRoot);
+  let invalidPausePath = null;
+  const marker = await readJsonFile(pausePath, null, {
+    fallbackInvalidJson: true,
+    onInvalidJson: ({ filePath }) => {
+      invalidPausePath = filePath;
+    }
+  });
+  if (invalidPausePath) {
+    return {
+      paused: true,
+      pausePath,
+      pausedAt: null,
+      pauseReason: INVALID_PAUSE_REASON,
+      pauseWarning: `Pause marker is not valid JSON: ${invalidPausePath}`
+    };
+  }
+  if (!marker) {
+    return {
+      paused: false,
+      pausePath,
+      pausedAt: null,
+      pauseReason: null,
+      pauseWarning: null
+    };
+  }
+  if (typeof marker !== "object") {
+    return {
+      paused: true,
+      pausePath,
+      pausedAt: null,
+      pauseReason: INVALID_PAUSE_REASON,
+      pauseWarning: `Pause marker is not valid JSON: ${pausePath}`
+    };
+  }
+  return {
+    paused: true,
+    pausePath,
+    pausedAt: marker.pausedAt || null,
+    pauseReason: marker.reason || null,
+    pauseWarning: null
+  };
+}
+
+// ../desktop/src/paths.mjs
+import fs3 from "node:fs/promises";
+import os from "node:os";
+import path3 from "node:path";
+function getDefaultLocalRoot() {
+  return path3.join(os.homedir(), "ZergBox");
+}
+function getDefaultConfigDir() {
+  if (process.platform === "darwin") {
+    return path3.join(os.homedir(), "Library", "Application Support", "ZergBox Desktop");
+  }
+  if (process.platform === "win32") {
+    return path3.join(process.env.APPDATA || path3.join(os.homedir(), "AppData", "Roaming"), "ZergBox Desktop");
+  }
+  return path3.join(process.env.XDG_CONFIG_HOME || path3.join(os.homedir(), ".config"), "zergbox-desktop");
+}
+function getDefaultConfigPath() {
+  return path3.join(getDefaultConfigDir(), "config.json");
+}
+function getDefaultStatePath(localRoot = getDefaultLocalRoot()) {
+  return path3.join(localRoot, ".zergbox-desktop", "state.json");
+}
+async function assertSafeLocalRoot(localRoot, home = os.homedir()) {
+  const resolvedRoot = resolveUsablePath(localRoot, "sync folder");
+  const resolvedHome = resolveUsablePath(home, "home directory");
+  const unexpectedRootSymlinks = await listUnexpectedPathSymlinks(resolvedRoot);
+  const rootResolution = await resolveProspectiveRealPath(resolvedRoot);
+  const homeResolution = await resolveProspectiveRealPath(resolvedHome);
+  const realRoot = rootResolution.prospectivePath;
+  const realHome = homeResolution.prospectivePath;
+  if (isUnsafeSyncRoot(resolvedRoot, resolvedHome) || isUnsafeSyncRoot(realRoot, realHome) || unexpectedRootSymlinks.length > 0 || rootResolution.existingAncestorIsSymlink && isUnsafeSyncRoot(rootResolution.realExistingAncestor, realHome)) {
+    throw new Error(`Refusing to use unsafe sync folder: ${localRoot}`);
+  }
+}
+async function assertSafeStatePath(statePath) {
+  const resolvedStatePath = resolveUsablePath(statePath, "sync state");
+  const unexpectedSymlinks = await listUnexpectedPathSymlinks(resolvedStatePath);
+  if (unexpectedSymlinks.length > 0) {
+    throw new Error(`Refusing to follow symbolic link in sync state path: ${statePath}`);
+  }
+}
+async function listUnexpectedPathSymlinks(filePath) {
+  const allowedPlatformSymlinks = new Set(await listAllowedPlatformSymlinks());
+  const symlinkComponents = await listExistingSymlinkComponents(filePath);
+  return symlinkComponents.filter((component) => !allowedPlatformSymlinks.has(component));
+}
+async function listAllowedPlatformSymlinks() {
+  if (process.platform !== "darwin") {
+    return [];
+  }
+  const symlinks = [];
+  for (const candidatePath of ["/var", "/tmp"]) {
+    try {
+      if ((await fs3.lstat(candidatePath)).isSymbolicLink()) {
+        symlinks.push(candidatePath);
+      }
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  return symlinks;
+}
+async function listExistingSymlinkComponents(filePath) {
+  const resolvedPath = path3.resolve(filePath);
+  const filesystemRoot = path3.parse(resolvedPath).root;
+  const segments = path3.relative(filesystemRoot, resolvedPath).split(path3.sep).filter(Boolean);
+  const symlinks = [];
+  let candidatePath = filesystemRoot;
+  for (const segment of segments) {
+    candidatePath = path3.join(candidatePath, segment);
+    try {
+      if ((await fs3.lstat(candidatePath)).isSymbolicLink()) {
+        symlinks.push(candidatePath);
+      }
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        break;
+      }
+      throw error;
+    }
+  }
+  return symlinks;
+}
+async function assertLocalPathHasNoSymlinks(localRoot, targetPath = localRoot) {
+  const resolvedRoot = resolveUsablePath(localRoot, "sync folder");
+  const resolvedTarget = resolveUsablePath(targetPath, "sync target");
+  const relativeTarget = path3.relative(resolvedRoot, resolvedTarget);
+  if (relativeTarget && (relativeTarget.startsWith("..") || path3.isAbsolute(relativeTarget))) {
+    throw new Error(`Sync path escapes local root: ${targetPath}`);
+  }
+  const pathSegments = relativeTarget ? relativeTarget.split(path3.sep).filter(Boolean) : [];
+  let candidatePath = resolvedRoot;
+  for (const segment of [null, ...pathSegments]) {
+    if (segment !== null) {
+      candidatePath = path3.join(candidatePath, segment);
+    }
+    let stats;
+    try {
+      stats = await fs3.lstat(candidatePath);
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+    if (stats.isSymbolicLink()) {
+      const relativePath = path3.relative(resolvedRoot, candidatePath).split(path3.sep).join("/") || ".";
+      throw new Error(`Refusing to follow symbolic link in sync folder: ${relativePath}`);
+    }
+  }
+}
+function resolveUsablePath(value, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${label} path is required`);
+  }
+  return path3.resolve(value);
+}
+async function resolveProspectiveRealPath(filePath) {
+  let existingAncestor = filePath;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const realExistingAncestor = await fs3.realpath(existingAncestor);
+      const existingAncestorStats = await fs3.lstat(existingAncestor);
+      return {
+        existingAncestor,
+        existingAncestorIsSymlink: existingAncestorStats.isSymbolicLink(),
+        realExistingAncestor,
+        prospectivePath: path3.resolve(realExistingAncestor, ...missingSegments)
+      };
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+      const parentPath = path3.dirname(existingAncestor);
+      if (parentPath === existingAncestor) {
+        throw error;
+      }
+      missingSegments.unshift(path3.basename(existingAncestor));
+      existingAncestor = parentPath;
+    }
+  }
+}
+function isUnsafeSyncRoot(candidateRoot, home) {
+  const filesystemRoot = path3.parse(candidateRoot).root;
+  return candidateRoot === filesystemRoot || isSamePathOrAncestor(candidateRoot, home);
+}
+function isSamePathOrAncestor(candidateRoot, target) {
+  const relative = path3.relative(candidateRoot, target);
+  return relative === "" || Boolean(relative && !relative.startsWith("..") && !path3.isAbsolute(relative));
+}
+
+// ../desktop/src/status.mjs
+import path4 from "node:path";
+var CONTROL_DIR2 = ".zergbox-desktop";
+var STATUS_FILE = "status.json";
+function getDesktopStatusPath(localRoot) {
+  return path4.join(localRoot, CONTROL_DIR2, STATUS_FILE);
+}
+async function writeDesktopStatus({ localRoot, status }) {
+  const statusPath = getDesktopStatusPath(localRoot);
+  const nextStatus = {
+    version: 1,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...status
+  };
+  await writeJsonFile(statusPath, nextStatus);
+  return nextStatus;
+}
+async function readDesktopStatus({ localRoot, onInvalidJson } = {}) {
+  return readJsonFile(getDesktopStatusPath(localRoot), null, {
+    fallbackInvalidJson: true,
+    onInvalidJson
+  });
+}
+
+// ../desktop/src/sync-scheduler.mjs
+var SyncScheduler = class {
+  constructor({ runOnce, debounceMs = 1e3, intervalMs = 3e4, onError = console.error } = {}) {
+    if (typeof runOnce !== "function") {
+      throw new Error("runOnce is required");
+    }
+    this.runOnce = runOnce;
+    this.debounceMs = debounceMs;
+    this.intervalMs = intervalMs;
+    this.onError = onError;
+    this.timer = null;
+    this.interval = null;
+    this.running = false;
+    this.pending = false;
+    this.stopped = false;
+    this.idleWaiters = [];
+  }
+  start({ immediate = true } = {}) {
+    this.stopped = false;
+    if (this.intervalMs > 0 && !this.interval) {
+      this.interval = setInterval(() => {
+        this.trigger("periodic");
+      }, this.intervalMs);
+    }
+    if (immediate) {
+      this.trigger("start");
+    }
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    return this.waitForIdle();
+  }
+  waitForIdle() {
+    if (!this.running) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.idleWaiters.push(resolve);
+    });
+  }
+  trigger(reason = "manual") {
+    if (this.stopped) {
+      return;
+    }
+    if (this.running) {
+      this.pending = true;
+      return;
+    }
+    if (this.timer) {
+      clearTimeout(this.timer);
+    }
+    this.timer = setTimeout(() => {
+      this.flush(reason);
+    }, this.debounceMs);
+  }
+  async flush(reason = "manual") {
+    if (this.stopped) {
+      return;
+    }
+    if (this.running) {
+      this.pending = true;
+      return;
+    }
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.running = true;
+    this.pending = false;
+    try {
+      await this.runOnce(reason);
+    } catch (error) {
+      this.onError(error);
+    } finally {
+      this.running = false;
+      for (const resolve of this.idleWaiters.splice(0)) {
+        resolve();
+      }
+      if (this.pending && !this.stopped) {
+        this.pending = false;
+        this.trigger("pending");
+      }
+    }
+  }
+};
+
+// ../desktop/src/sync-runner.mjs
+import crypto3 from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import fs6 from "node:fs/promises";
+import path7 from "node:path";
+import posixPath from "node:path/posix";
+
+// ../desktop/src/local-scan.mjs
+import crypto from "node:crypto";
+import fs4 from "node:fs";
+import fsp from "node:fs/promises";
+import path5 from "node:path";
+function isTransientScanError(error) {
+  return ["ENOENT", "ENOTDIR", "EISDIR"].includes(error?.code);
+}
+function normalizeLocalRelativePath(relativePath) {
+  if (path5.sep === "\\") {
+    return normalizeSyncPath(relativePath);
+  }
+  return String(relativePath || "").split("/").filter((part) => part && part !== ".").join("/");
+}
+async function hashFile(root, filePath) {
+  await assertLocalPathHasNoSymlinks(root, filePath);
+  const hash = crypto.createHash("sha256");
+  const stream = fs4.createReadStream(filePath);
+  for await (const chunk of stream) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+async function walk(root, current, entries, ignorePatterns) {
+  await assertLocalPathHasNoSymlinks(root, current);
+  let dirents;
+  try {
+    dirents = await fsp.readdir(current, { withFileTypes: true });
+  } catch (error) {
+    if (isTransientScanError(error)) {
+      return false;
+    }
+    throw error;
+  }
+  for (const dirent of dirents) {
+    const absolutePath = path5.join(current, dirent.name);
+    const relativePath = normalizeLocalRelativePath(path5.relative(root, absolutePath));
+    if (!relativePath || isSyncPathIgnored(relativePath, ignorePatterns)) {
+      continue;
+    }
+    if (dirent.isSymbolicLink()) {
+      throw new Error(`Refusing to follow symbolic link in sync folder: ${relativePath}`);
+    }
+    let stat;
+    try {
+      stat = await fsp.lstat(absolutePath);
+    } catch (error) {
+      if (isTransientScanError(error)) {
+        continue;
+      }
+      throw error;
+    }
+    if (stat.isSymbolicLink()) {
+      throw new Error(`Refusing to follow symbolic link in sync folder: ${relativePath}`);
+    }
+    if (dirent.isDirectory()) {
+      const childEntries = [];
+      const directoryExists = await walk(root, absolutePath, childEntries, ignorePatterns);
+      if (!directoryExists) {
+        continue;
+      }
+      entries.push({
+        path: relativePath,
+        type: "directory",
+        mtimeMs: stat.mtimeMs
+      });
+      entries.push(...childEntries);
+      continue;
+    }
+    if (dirent.isFile()) {
+      let contentHash;
+      try {
+        contentHash = await hashFile(root, absolutePath);
+      } catch (error) {
+        if (isTransientScanError(error)) {
+          continue;
+        }
+        throw error;
+      }
+      entries.push({
+        path: relativePath,
+        type: "file",
+        contentHash,
+        sizeBytes: stat.size,
+        mtimeMs: stat.mtimeMs
+      });
+    }
+  }
+  return true;
+}
+async function scanLocalTree(localRoot, options = {}) {
+  const ignorePatterns = options.ignorePatterns || DEFAULT_IGNORE_PATTERNS;
+  await fsp.mkdir(localRoot, { recursive: true });
+  await assertLocalPathHasNoSymlinks(localRoot);
+  const entries = [];
+  await walk(localRoot, localRoot, entries, ignorePatterns);
+  return entries.sort((a, b) => a.path.localeCompare(b.path));
+}
+
+// ../desktop/src/sync-lock.mjs
+import crypto2 from "node:crypto";
+import fs5 from "node:fs/promises";
+import os2 from "node:os";
+import path6 from "node:path";
+var CONTROL_DIR3 = ".zergbox-desktop";
+var LOCK_DIR = "sync.lock";
+var OWNER_FILE = "owner.json";
+var DEFAULT_STALE_LOCK_MS = 6 * 60 * 60 * 1e3;
+function getSyncLockPath(localRoot) {
+  return path6.join(localRoot, CONTROL_DIR3, LOCK_DIR);
+}
+function getLockOwnerPath(lockPath) {
+  return path6.join(lockPath, OWNER_FILE);
+}
+function isProcessAlive(pid) {
+  const processId = Number(pid);
+  if (!Number.isInteger(processId) || processId <= 0) {
+    return false;
+  }
+  try {
+    process.kill(processId, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+async function readLockOwner(lockPath) {
+  return readJsonFile(getLockOwnerPath(lockPath), null, { fallbackInvalidJson: true });
+}
+function getOwnerTimestampMs(owner, lockStat) {
+  const acquiredAt = Date.parse(String(owner?.acquiredAt || ""));
+  if (Number.isFinite(acquiredAt)) {
+    return acquiredAt;
+  }
+  return lockStat.mtimeMs;
+}
+function isStaleLock({ owner, lockStat, nowMs, staleLockMs, hostname }) {
+  if (owner?.hostname === hostname && owner.pid !== void 0) {
+    return !isProcessAlive(owner.pid);
+  }
+  return nowMs - getOwnerTimestampMs(owner, lockStat) > staleLockMs;
+}
+async function releaseSyncLock(lock) {
+  const owner = await readLockOwner(lock.lockPath);
+  if (owner?.token !== lock.token) {
+    return;
+  }
+  await fs5.rm(lock.lockPath, { recursive: true, force: true });
+}
+async function acquireSyncLock({
+  localRoot,
+  staleLockMs = DEFAULT_STALE_LOCK_MS,
+  now = () => Date.now(),
+  hostname = os2.hostname(),
+  pid = process.pid
+}) {
+  const lockPath = getSyncLockPath(localRoot);
+  const token = crypto2.randomUUID();
+  const owner = {
+    version: 1,
+    token,
+    pid,
+    hostname,
+    acquiredAt: new Date(now()).toISOString()
+  };
+  await fs5.mkdir(path6.dirname(lockPath), { recursive: true, mode: 448 });
+  while (true) {
+    try {
+      await fs5.mkdir(lockPath, { mode: 448 });
+      try {
+        await writeJsonFile(getLockOwnerPath(lockPath), owner);
+      } catch (error) {
+        await fs5.rm(lockPath, { recursive: true, force: true });
+        throw error;
+      }
+      return {
+        acquired: true,
+        lockPath,
+        token,
+        owner,
+        release: () => releaseSyncLock({ lockPath, token })
+      };
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        throw error;
+      }
+    }
+    let lockStat;
+    try {
+      lockStat = await fs5.stat(lockPath);
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+    const existingOwner = await readLockOwner(lockPath);
+    if (isStaleLock({
+      owner: existingOwner,
+      lockStat,
+      nowMs: now(),
+      staleLockMs,
+      hostname
+    })) {
+      await fs5.rm(lockPath, { recursive: true, force: true });
+      continue;
+    }
+    return {
+      acquired: false,
+      lockPath,
+      owner: existingOwner,
+      release: async () => {
+      }
+    };
+  }
+}
+
+// ../desktop/src/sync-runner.mjs
+function dirname(remotePath) {
+  const parent = posixPath.dirname(remotePath);
+  return parent === "." ? "" : parent;
+}
+function basename(remotePath) {
+  return posixPath.basename(remotePath);
+}
+function indexRemoteFolders(rootFolder, remoteEntries) {
+  const folders = /* @__PURE__ */ new Map([["", rootFolder.id]]);
+  for (const entry of remoteEntries) {
+    if (entry.type === "directory") {
+      folders.set(entry.path, entry.id);
+    }
+  }
+  return folders;
+}
+function fetchConfiguredRemoteTree(client, config) {
+  return fetchRemoteTree(client, {
+    orgId: config.organizationId,
+    rootFolderId: config.rootFolderId
+  });
+}
+async function ensureRemoteFolder(client, { orgId, rootFolderId, remoteFolders, folderPath }) {
+  const normalizedPath = normalizeSyncPath(folderPath);
+  if (!normalizedPath) {
+    return rootFolderId;
+  }
+  const existing = remoteFolders.get(normalizedPath);
+  if (existing) {
+    return existing;
+  }
+  let parentId = rootFolderId;
+  let currentPath = "";
+  for (const segment of normalizedPath.split("/")) {
+    currentPath = normalizeSyncPath(currentPath ? `${currentPath}/${segment}` : segment);
+    if (remoteFolders.has(currentPath)) {
+      parentId = remoteFolders.get(currentPath);
+      continue;
+    }
+    const result = await client.createFolder({
+      orgId,
+      parentFolderId: parentId,
+      name: segment,
+      expectedAbsent: true
+    });
+    const folderId = result.folder?.id || result.id;
+    remoteFolders.set(currentPath, folderId);
+    parentId = folderId;
+  }
+  return parentId;
+}
+async function writeConflictMarker(localRoot, action) {
+  const conflictDir = path7.join(localRoot, ".zergbox-desktop", "conflicts");
+  const hash = getConflictIdentityHash(action);
+  const label = String(action.path || "conflict").replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 96) || "conflict";
+  const filename = `${label}-${hash}.json`;
+  const markerPath = path7.join(conflictDir, filename);
+  await fs6.mkdir(conflictDir, { recursive: true });
+  try {
+    await fs6.writeFile(markerPath, `${JSON.stringify(action, null, 2)}
+`, { flag: "wx" });
+  } catch (error) {
+    if (error?.code === "EEXIST") {
+      return;
+    }
+    throw error;
+  }
+}
+function getConflictIdentityHash(action) {
+  const identity = JSON.stringify({
+    path: action.path,
+    remoteId: action.remoteId || null
+  });
+  return crypto3.createHash("sha256").update(identity).digest("hex").slice(0, 16);
+}
+async function pruneResolvedConflictMarkers(localRoot, conflictActions) {
+  const conflictDir = path7.join(localRoot, ".zergbox-desktop", "conflicts");
+  const activeHashes = new Set(conflictActions.map(getConflictIdentityHash));
+  let markerNames;
+  try {
+    markerNames = await fs6.readdir(conflictDir);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  await Promise.all(markerNames.map(async (markerName) => {
+    const markerPath = path7.join(conflictDir, markerName);
+    let marker;
+    try {
+      marker = JSON.parse(await fs6.readFile(markerPath, "utf8"));
+    } catch {
+      return;
+    }
+    if (marker?.type !== "conflict" || typeof marker.path !== "string") {
+      return;
+    }
+    if (!activeHashes.has(getConflictIdentityHash(marker))) {
+      await fs6.rm(markerPath, { force: true });
+    }
+  }));
+}
+async function writeFileAtomically(filePath, data, options = {}) {
+  const directory = path7.dirname(filePath);
+  const tempPath = path7.join(directory, `.${path7.basename(filePath)}.zergbox-download`);
+  const replace = options.replace !== false;
+  await assertLocalPathHasNoSymlinks(options.localRoot, directory);
+  await fs6.mkdir(directory, { recursive: true });
+  await assertLocalPathHasNoSymlinks(options.localRoot, filePath);
+  await assertLocalPathHasNoSymlinks(options.localRoot, tempPath);
+  try {
+    await fs6.writeFile(tempPath, data, { flag: "wx" });
+    if (replace) {
+      await assertLocalFileStillMatches(filePath, options.expectedLocalHash, options.syncPath || filePath);
+      await assertLocalPathHasNoSymlinks(options.localRoot, filePath);
+      await fs6.rename(tempPath, filePath);
+    } else {
+      await assertLocalPathHasNoSymlinks(options.localRoot, filePath);
+      await fs6.copyFile(tempPath, filePath, fsConstants.COPYFILE_EXCL);
+    }
+  } catch (error) {
+    if (!replace && isDestinationExistsError(error)) {
+      throw makeLocalDestinationExistsError(options.syncPath || filePath);
+    }
+    throw error;
+  } finally {
+    await fs6.rm(tempPath, { force: true });
+  }
+}
+async function assertLocalFileStillMatches(filePath, expectedHash, syncPath) {
+  if (!expectedHash) {
+    return;
+  }
+  let data;
+  try {
+    data = await fs6.readFile(filePath);
+  } catch (error) {
+    throw makeLocalChangedAfterScanError(syncPath, error);
+  }
+  const currentHash = crypto3.createHash("sha256").update(data).digest("hex");
+  if (currentHash !== expectedHash) {
+    throw makeLocalChangedAfterScanError(syncPath);
+  }
+}
+async function assertLocalPathStillAbsent(filePath, syncPath) {
+  try {
+    await fs6.lstat(filePath);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return;
+    }
+    throw makeLocalChangedAfterScanError(syncPath, error);
+  }
+  throw makeLocalChangedAfterScanError(syncPath);
+}
+async function assertLocalUploadSourceStillMatches(filePath, expectedHash, syncPath) {
+  if (!expectedHash) {
+    return;
+  }
+  let data;
+  try {
+    data = await fs6.readFile(filePath);
+  } catch (error) {
+    throw makeLocalSourceChangedAfterScanError(syncPath, error);
+  }
+  const currentHash = crypto3.createHash("sha256").update(data).digest("hex");
+  if (currentHash !== expectedHash) {
+    throw makeLocalSourceChangedAfterScanError(syncPath);
+  }
+}
+async function assertLocalMoveSourceStillMatches(filePath, expectedHash, syncPath) {
+  if (!expectedHash) {
+    throw makeLocalSourceChangedAfterScanError(syncPath);
+  }
+  let data;
+  try {
+    data = await fs6.readFile(filePath);
+  } catch (error) {
+    throw makeLocalSourceChangedAfterScanError(syncPath, error);
+  }
+  const currentHash = crypto3.createHash("sha256").update(data).digest("hex");
+  if (currentHash !== expectedHash) {
+    throw makeLocalSourceChangedAfterScanError(syncPath);
+  }
+}
+async function assertLocalDeleteTargetStillMatches(filePath, expectedHash, syncPath) {
+  if (!expectedHash) {
+    return;
+  }
+  let data;
+  try {
+    data = await fs6.readFile(filePath);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return;
+    }
+    throw makeLocalChangedAfterScanError(syncPath, error);
+  }
+  const currentHash = crypto3.createHash("sha256").update(data).digest("hex");
+  if (currentHash !== expectedHash) {
+    throw makeLocalChangedAfterScanError(syncPath);
+  }
+}
+function collectLocalSubtreeEntries(entries, syncPath) {
+  const normalizedPath = normalizeSyncPath(syncPath);
+  const subtreeEntries = /* @__PURE__ */ new Map();
+  const iterableEntries = entries instanceof Map ? entries.values() : entries;
+  for (const entry of iterableEntries || []) {
+    if (pathIsWithin(entry.path, normalizedPath)) {
+      subtreeEntries.set(entry.path, entry);
+    }
+  }
+  return subtreeEntries;
+}
+function localSubtreeStillMatches(expectedEntries, currentEntries) {
+  if (currentEntries.size === 0) {
+    return true;
+  }
+  if (expectedEntries.size !== currentEntries.size) {
+    return false;
+  }
+  for (const [entryPath, expectedEntry] of expectedEntries) {
+    const currentEntry = currentEntries.get(entryPath);
+    if (!currentEntry || currentEntry.type !== expectedEntry.type) {
+      return false;
+    }
+    if (currentEntry.revision !== expectedEntry.revision) {
+      return false;
+    }
+    if (expectedEntry.type === "file" && currentEntry.contentHash !== expectedEntry.contentHash) {
+      return false;
+    }
+  }
+  return true;
+}
+function localSubtreeExactlyMatches(expectedEntries, currentEntries) {
+  if (expectedEntries.size !== currentEntries.size) {
+    return false;
+  }
+  for (const [entryPath, expectedEntry] of expectedEntries) {
+    const currentEntry = currentEntries.get(entryPath);
+    if (!currentEntry || currentEntry.type !== expectedEntry.type) {
+      return false;
+    }
+    if (expectedEntry.type === "file" && currentEntry.contentHash !== expectedEntry.contentHash) {
+      return false;
+    }
+  }
+  return true;
+}
+async function assertLocalFolderDeleteTargetStillMatches(localRoot, expectedEntries, syncPath) {
+  const currentEntries = collectLocalSubtreeEntries(await scanLocalTree(localRoot), syncPath);
+  if (!localSubtreeStillMatches(expectedEntries, currentEntries)) {
+    throw makeLocalChangedAfterScanError(syncPath);
+  }
+}
+async function assertLocalFolderMoveSourceStillMatches(localRoot, expectedEntries, syncPath) {
+  const currentEntries = collectLocalSubtreeEntries(await scanLocalTree(localRoot), syncPath);
+  if (!localSubtreeExactlyMatches(expectedEntries, currentEntries)) {
+    throw makeLocalChangedAfterScanError(syncPath);
+  }
+}
+function collectRemoteSubtreeEntries(entries, syncPath) {
+  const normalizedPath = normalizeSyncPath(syncPath);
+  const subtreeEntries = /* @__PURE__ */ new Map();
+  const iterableEntries = entries instanceof Map ? entries.values() : entries;
+  for (const entry of iterableEntries || []) {
+    if (pathIsWithin(entry.path, normalizedPath)) {
+      subtreeEntries.set(entry.path, entry);
+    }
+  }
+  return subtreeEntries;
+}
+function remoteSubtreeStillMatches(expectedEntries, currentEntries) {
+  if (expectedEntries.size !== currentEntries.size) {
+    return false;
+  }
+  for (const [entryPath, expectedEntry] of expectedEntries) {
+    const currentEntry = currentEntries.get(entryPath);
+    if (!currentEntry || currentEntry.type !== expectedEntry.type || currentEntry.id !== expectedEntry.id) {
+      return false;
+    }
+    if (expectedEntry.type === "file" && currentEntry.contentHash !== expectedEntry.contentHash) {
+      return false;
+    }
+  }
+  return true;
+}
+async function assertRemoteFolderDeleteTargetStillMatches(client, config, expectedEntries, action) {
+  const currentRemoteTree = await fetchConfiguredRemoteTree(client, config);
+  const currentTarget = currentRemoteTree.entries.find((entry) => entry.id === action.remoteId);
+  if (!currentTarget) {
+    return { alreadyGone: true };
+  }
+  if (currentTarget.type !== "directory" || currentTarget.path !== action.path) {
+    throw makeRemoteChangedAfterScanError(action.path);
+  }
+  const currentEntries = collectRemoteSubtreeEntries(currentRemoteTree.entries, action.path);
+  if (!remoteSubtreeStillMatches(expectedEntries, currentEntries)) {
+    throw makeRemoteChangedAfterScanError(action.path);
+  }
+  return { alreadyGone: false };
+}
+async function assertRemoteFileDeleteTargetStillMatches(client, config, expectedEntry, action) {
+  const currentRemoteTree = await fetchConfiguredRemoteTree(client, config);
+  const currentTarget = currentRemoteTree.entries.find((entry) => entry.id === action.remoteId);
+  if (!currentTarget) {
+    return { alreadyGone: true };
+  }
+  if (currentTarget.type !== "file" || currentTarget.path !== action.path || currentTarget.contentHash !== expectedEntry?.contentHash || currentTarget.revision !== expectedEntry?.revision) {
+    throw makeRemoteChangedAfterScanError(action.path);
+  }
+  return { alreadyGone: false };
+}
+async function assertRemoteFileAtPathStillMatches(client, config, expectedEntry, action, syncPath = action.path) {
+  const currentRemoteTree = await fetchConfiguredRemoteTree(client, config);
+  const currentTarget = currentRemoteTree.entries.find((entry) => entry.id === action.remoteId);
+  if (!currentTarget || currentTarget.type !== "file" || currentTarget.path !== action.path || currentTarget.contentHash !== expectedEntry?.contentHash || currentTarget.revision !== expectedEntry?.revision) {
+    throw makeRemoteChangedAfterScanError(syncPath);
+  }
+  return currentTarget;
+}
+async function assertRemotePathStillAbsent(client, config, syncPath) {
+  const currentRemoteTree = await fetchConfiguredRemoteTree(client, config);
+  const currentTarget = currentRemoteTree.entries.find((entry) => entry.path === syncPath);
+  if (currentTarget) {
+    throw makeRemoteChangedAfterScanError(syncPath);
+  }
+}
+async function assertRemoteFileMoveSourceStillMatches(client, config, expectedEntry, action) {
+  const currentRemoteTree = await fetchConfiguredRemoteTree(client, config);
+  const currentTarget = currentRemoteTree.entries.find((entry) => entry.id === action.remoteId);
+  const currentDestination = currentRemoteTree.entries.find((entry) => {
+    return entry.path === action.path && entry.id !== action.remoteId;
+  });
+  if (!currentTarget || currentTarget.type !== "file" || currentTarget.path !== action.fromPath || currentTarget.contentHash !== expectedEntry?.contentHash || currentTarget.revision !== expectedEntry?.revision || currentDestination) {
+    throw makeRemoteChangedAfterScanError(action.fromPath);
+  }
+  return currentTarget;
+}
+async function assertRemoteFolderMoveSourceStillMatches(client, config, expectedEntries, action) {
+  const currentRemoteTree = await fetchConfiguredRemoteTree(client, config);
+  const currentTarget = currentRemoteTree.entries.find((entry) => entry.id === action.remoteId);
+  const currentDestination = currentRemoteTree.entries.find((entry) => {
+    return entry.path === action.path && entry.id !== action.remoteId;
+  });
+  if (!currentTarget || currentTarget.type !== "directory" || currentTarget.path !== action.fromPath || currentTarget.revision !== expectedEntries.get(action.fromPath)?.revision || currentDestination) {
+    throw makeRemoteChangedAfterScanError(action.fromPath);
+  }
+  const currentEntries = collectRemoteSubtreeEntries(currentRemoteTree.entries, action.fromPath);
+  if (!remoteSubtreeStillMatches(expectedEntries, currentEntries)) {
+    throw makeRemoteChangedAfterScanError(action.fromPath);
+  }
+  return currentTarget;
+}
+function makeLocalChangedAfterScanError(syncPath, cause) {
+  const error = new Error(`Local sync destination changed after sync scan: ${syncPath}`);
+  error.code = "ESTALE";
+  if (cause) {
+    error.cause = cause;
+  }
+  return error;
+}
+function makeLocalSourceChangedAfterScanError(syncPath, cause) {
+  const error = new Error(`Local sync source changed after sync scan: ${syncPath}`);
+  error.code = "ESTALE";
+  if (cause) {
+    error.cause = cause;
+  }
+  return error;
+}
+function makeLocalDestinationExistsError(syncPath) {
+  const error = new Error(`Local sync destination already exists: ${syncPath}`);
+  error.code = "EEXIST";
+  return error;
+}
+function makeRemoteChangedAfterScanError(syncPath) {
+  const error = new Error(`Remote sync target changed after sync scan: ${syncPath}`);
+  error.code = "ESTALE";
+  return error;
+}
+function isDestinationExistsError(error) {
+  return ["EEXIST", "ENOTEMPTY", "EISDIR", "ERR_FS_CP_EEXIST"].includes(error?.code);
+}
+async function moveLocalFileWithoutReplacing(fromPath, toPath, syncPath) {
+  try {
+    await fs6.copyFile(fromPath, toPath, fsConstants.COPYFILE_EXCL);
+  } catch (error) {
+    if (isDestinationExistsError(error)) {
+      throw makeLocalDestinationExistsError(syncPath);
+    }
+    throw error;
+  }
+  await fs6.unlink(fromPath);
+}
+async function moveLocalDirectoryWithoutReplacing(fromPath, toPath, syncPath, options = {}) {
+  let destinationCreated = false;
+  try {
+    await fs6.mkdir(toPath);
+    destinationCreated = true;
+    await options.validateSource?.();
+  } catch (error) {
+    if (destinationCreated) {
+      await fs6.rm(toPath, { recursive: true, force: true });
+    }
+    if (isDestinationExistsError(error)) {
+      throw makeLocalDestinationExistsError(syncPath);
+    }
+    throw error;
+  }
+  try {
+    for (const name of await fs6.readdir(fromPath)) {
+      await fs6.cp(path7.join(fromPath, name), path7.join(toPath, name), {
+        recursive: true,
+        force: false,
+        errorOnExist: true
+      });
+    }
+    await fs6.rm(fromPath, { recursive: true, force: false });
+  } catch (error) {
+    if (isDestinationExistsError(error)) {
+      throw makeLocalDestinationExistsError(syncPath);
+    }
+    throw error;
+  }
+}
+function resolveLocalSyncPath(localRoot, syncPath) {
+  if (!isSafeSyncPath(syncPath)) {
+    throw new Error(`Unsafe sync path: ${syncPath}`);
+  }
+  const root = path7.resolve(localRoot);
+  const localPath = path7.resolve(root, ...normalizeSyncPath(syncPath).split("/"));
+  const relativePath = path7.relative(root, localPath);
+  if (relativePath && (relativePath.startsWith("..") || path7.isAbsolute(relativePath))) {
+    throw new Error(`Sync path escapes local root: ${syncPath}`);
+  }
+  return localPath;
+}
+function buildSyncState(localEntries, remoteEntries, syncedAt, options = {}) {
+  const remoteByPath = new Map(remoteEntries.map((entry) => [entry.path, entry]));
+  const skipPaths = options.skipPaths || /* @__PURE__ */ new Set();
+  const entries = {};
+  for (const localEntry of localEntries) {
+    if (isSkippedSyncStatePath(localEntry.path, skipPaths)) {
+      continue;
+    }
+    const remoteEntry = remoteByPath.get(localEntry.path);
+    if (!remoteEntry || localEntry.type !== remoteEntry.type) {
+      continue;
+    }
+    entries[localEntry.path] = {
+      type: localEntry.type,
+      remoteId: remoteEntry.id,
+      localHash: localEntry.type === "file" ? localEntry.contentHash : null,
+      remoteHash: remoteEntry.type === "file" ? remoteEntry.contentHash : null,
+      syncedAt
+    };
+  }
+  return {
+    version: 1,
+    syncedAt,
+    entries
+  };
+}
+function syncStateEntryMatchesCandidate(stateEntry, candidateEntry) {
+  if (!stateEntry || !candidateEntry || stateEntry.type !== candidateEntry.type || stateEntry.remoteId !== candidateEntry.remoteId) {
+    return false;
+  }
+  if (stateEntry.type === "directory") {
+    return true;
+  }
+  return stateEntry.localHash === candidateEntry.localHash && stateEntry.remoteHash === candidateEntry.remoteHash;
+}
+function buildStableFinalSyncState(localEntries, remoteEntries, syncedAt, options = {}) {
+  const candidateState = buildSyncState(localEntries, remoteEntries, syncedAt, options);
+  const incrementalState = options.incrementalState;
+  if (!incrementalState) {
+    return candidateState;
+  }
+  const baselineLocalByPath = new Map((options.baselineLocalEntries || []).map((entry) => [entry.path, entry]));
+  const baselineRemoteByPath = new Map((options.baselineRemoteEntries || []).map((entry) => [entry.path, entry]));
+  const skipPaths = options.skipPaths || /* @__PURE__ */ new Set();
+  const entries = {};
+  for (const [entryPath, stateEntry] of Object.entries(incrementalState.entries || {})) {
+    if (isSkippedSyncStatePath(entryPath, skipPaths)) {
+      continue;
+    }
+    const candidateEntry = candidateState.entries[entryPath];
+    if (syncStateEntryMatchesCandidate(stateEntry, candidateEntry)) {
+      entries[entryPath] = candidateEntry;
+      continue;
+    }
+    if (baselineLocalByPath.has(entryPath) || baselineRemoteByPath.has(entryPath)) {
+      entries[entryPath] = stateEntry;
+    }
+  }
+  for (const [entryPath, candidateEntry] of Object.entries(candidateState.entries)) {
+    if (entries[entryPath] || candidateEntry.type !== "directory") {
+      continue;
+    }
+    entries[entryPath] = candidateEntry;
+  }
+  return {
+    version: 1,
+    syncedAt,
+    entries
+  };
+}
+function isSkippedSyncStatePath(syncPath, skipPaths) {
+  for (const skipPath of skipPaths) {
+    if (!skipPath) {
+      continue;
+    }
+    if (syncPath === skipPath || syncPath.startsWith(`${skipPath}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function cloneSyncState(state) {
+  return {
+    version: 1,
+    syncedAt: state.syncedAt || null,
+    entries: { ...state.entries || {} }
+  };
+}
+function removeStatePath(syncState, syncPath) {
+  const normalizedPath = normalizeSyncPath(syncPath);
+  if (!normalizedPath) {
+    return;
+  }
+  for (const path9 of Object.keys(syncState.entries || {})) {
+    if (path9 === normalizedPath || path9.startsWith(`${normalizedPath}/`)) {
+      delete syncState.entries[path9];
+    }
+  }
+}
+function pathIsWithin(syncPath, parentPath) {
+  return syncPath === parentPath || syncPath.startsWith(`${parentPath}/`);
+}
+function replacePathPrefix(syncPath, fromPath, toPath) {
+  if (syncPath === fromPath) {
+    return toPath;
+  }
+  return `${toPath}/${syncPath.slice(fromPath.length + 1)}`;
+}
+function moveStatePath(syncState, fromPath, toPath, syncedAt) {
+  const nextEntries = {};
+  for (const [entryPath, entry] of Object.entries(syncState.entries || {})) {
+    if (pathIsWithin(entryPath, fromPath)) {
+      nextEntries[replacePathPrefix(entryPath, fromPath, toPath)] = {
+        ...entry,
+        syncedAt
+      };
+      continue;
+    }
+    nextEntries[entryPath] = entry;
+  }
+  syncState.entries = nextEntries;
+}
+function rekeyRemoteFolders(remoteFolders, fromPath, toPath) {
+  const updates = [];
+  for (const [folderPath, folderId] of remoteFolders) {
+    if (pathIsWithin(folderPath, fromPath)) {
+      updates.push({
+        oldPath: folderPath,
+        newPath: replacePathPrefix(folderPath, fromPath, toPath),
+        folderId
+      });
+    }
+  }
+  for (const update of updates) {
+    remoteFolders.delete(update.oldPath);
+  }
+  for (const update of updates) {
+    remoteFolders.set(update.newPath, update.folderId);
+  }
+}
+function getResponseFile(result) {
+  return result?.file || result;
+}
+function buildFileStateEntry({ remoteId, localHash, remoteHash }) {
+  if (!remoteId || !localHash || !remoteHash) {
+    return null;
+  }
+  return {
+    type: "file",
+    remoteId,
+    localHash,
+    remoteHash
+  };
+}
+function buildDirectoryStateEntry({ remoteId }) {
+  if (!remoteId) {
+    return null;
+  }
+  return {
+    type: "directory",
+    remoteId,
+    localHash: null,
+    remoteHash: null
+  };
+}
+function applyStateMutation(syncState, mutation, syncedAt) {
+  if (!mutation) {
+    return false;
+  }
+  let changed = false;
+  if (mutation.removePath) {
+    removeStatePath(syncState, mutation.removePath);
+    changed = true;
+  }
+  if (mutation.movePath) {
+    moveStatePath(syncState, mutation.movePath.fromPath, mutation.movePath.path, syncedAt);
+    changed = true;
+  }
+  if (mutation.entryPath && mutation.entry) {
+    syncState.entries[mutation.entryPath] = {
+      ...mutation.entry,
+      syncedAt
+    };
+    changed = true;
+  }
+  return changed;
+}
+function countConflicts(actions) {
+  return actions.filter((action) => action.type === "conflict").length;
+}
+async function getLastKnownSyncedAt(config) {
+  try {
+    const status = await readDesktopStatus({ localRoot: config.localRoot });
+    if (status?.lastSyncedAt) {
+      return status.lastSyncedAt;
+    }
+    const state = await readJsonFile(config.statePath, null, {
+      fallbackInvalidJson: true,
+      assertSafePath: assertSafeStatePath
+    });
+    return state?.syncedAt || null;
+  } catch {
+    return null;
+  }
+}
+async function applyAction(client, config, context, action) {
+  switch (action.type) {
+    case "create_remote_folder": {
+      await assertRemotePathStillAbsent(client, config, action.path);
+      const folderId = await ensureRemoteFolder(client, {
+        orgId: config.organizationId,
+        rootFolderId: context.rootFolder.id,
+        remoteFolders: context.remoteFolders,
+        folderPath: action.path
+      });
+      const entry = buildDirectoryStateEntry({ remoteId: folderId });
+      return entry ? { entryPath: action.path, entry } : null;
+    }
+    case "upload_file": {
+      const localPath = resolveLocalSyncPath(config.localRoot, action.path);
+      const localEntry = context.localEntries.get(action.path);
+      let result;
+      await assertLocalPathHasNoSymlinks(config.localRoot, localPath);
+      if (action.remoteId) {
+        const currentRemote = await assertRemoteFileAtPathStillMatches(
+          client,
+          config,
+          context.remoteEntries.get(action.path),
+          action
+        );
+        result = await client.updateFileContent({
+          fileId: action.remoteId,
+          filePath: localPath,
+          expectedRevision: currentRemote.revision
+        });
+      } else {
+        await assertRemotePathStillAbsent(client, config, action.path);
+        const folderId = await ensureRemoteFolder(client, {
+          orgId: config.organizationId,
+          rootFolderId: context.rootFolder.id,
+          remoteFolders: context.remoteFolders,
+          folderPath: dirname(action.path)
+        });
+        result = await client.uploadFile({
+          orgId: config.organizationId,
+          folderId,
+          filePath: localPath,
+          filename: basename(action.path),
+          replaceExisting: false
+        });
+      }
+      const file = getResponseFile(result);
+      await assertLocalUploadSourceStillMatches(localPath, localEntry?.contentHash, action.path);
+      const entry = buildFileStateEntry({
+        remoteId: file?.id || action.remoteId,
+        localHash: localEntry?.contentHash,
+        remoteHash: file ? remoteFileFingerprint(file) : null
+      });
+      return entry ? { entryPath: action.path, entry } : null;
+    }
+    case "move_remote_file": {
+      const localEntry = context.localEntries.get(action.path);
+      const existingRemoteEntry = context.remoteEntries.get(action.fromPath);
+      const currentRemote = await assertRemoteFileMoveSourceStillMatches(
+        client,
+        config,
+        existingRemoteEntry,
+        action
+      );
+      const folderId = await ensureRemoteFolder(client, {
+        orgId: config.organizationId,
+        rootFolderId: context.rootFolder.id,
+        remoteFolders: context.remoteFolders,
+        folderPath: dirname(action.path)
+      });
+      const result = await client.updateFile({
+        fileId: action.remoteId,
+        folderId,
+        name: basename(action.path),
+        expectedRevision: currentRemote.revision
+      });
+      const file = getResponseFile(result);
+      const entry = buildFileStateEntry({
+        remoteId: file?.id || action.remoteId,
+        localHash: localEntry?.contentHash,
+        remoteHash: file ? remoteFileFingerprint(file) : existingRemoteEntry?.contentHash
+      });
+      return entry ? { removePath: action.fromPath, entryPath: action.path, entry } : { removePath: action.fromPath };
+    }
+    case "move_remote_folder": {
+      const currentRemote = await assertRemoteFolderMoveSourceStillMatches(
+        client,
+        config,
+        collectRemoteSubtreeEntries(context.remoteEntries, action.fromPath),
+        action
+      );
+      const parentFolderId = await ensureRemoteFolder(client, {
+        orgId: config.organizationId,
+        rootFolderId: context.rootFolder.id,
+        remoteFolders: context.remoteFolders,
+        folderPath: dirname(action.path)
+      });
+      await client.updateFolder({
+        folderId: action.remoteId,
+        parentFolderId,
+        name: basename(action.path),
+        expectedRevision: currentRemote.revision
+      });
+      rekeyRemoteFolders(context.remoteFolders, action.fromPath, action.path);
+      return { movePath: { fromPath: action.fromPath, path: action.path } };
+    }
+    case "create_local_folder": {
+      const localPath = resolveLocalSyncPath(config.localRoot, action.path);
+      await assertLocalPathHasNoSymlinks(config.localRoot, localPath);
+      await assertLocalPathStillAbsent(localPath, action.path);
+      await fs6.mkdir(localPath, { recursive: true });
+      await assertLocalPathHasNoSymlinks(config.localRoot, localPath);
+      const remoteEntry = context.remoteEntries.get(action.path);
+      const entry = buildDirectoryStateEntry({ remoteId: action.remoteId || remoteEntry?.id });
+      return entry ? { entryPath: action.path, entry } : null;
+    }
+    case "move_local_file": {
+      const fromLocalPath = resolveLocalSyncPath(config.localRoot, action.fromPath);
+      const toLocalPath = resolveLocalSyncPath(config.localRoot, action.path);
+      const localEntry = context.localEntries.get(action.fromPath);
+      const remoteEntry = context.remoteEntries.get(action.path);
+      await assertLocalPathHasNoSymlinks(config.localRoot, fromLocalPath);
+      await assertLocalPathHasNoSymlinks(config.localRoot, toLocalPath);
+      await fs6.mkdir(path7.dirname(toLocalPath), { recursive: true });
+      await assertLocalPathHasNoSymlinks(config.localRoot, toLocalPath);
+      await assertLocalMoveSourceStillMatches(fromLocalPath, localEntry?.contentHash, action.fromPath);
+      await assertLocalPathHasNoSymlinks(config.localRoot, fromLocalPath);
+      await moveLocalFileWithoutReplacing(fromLocalPath, toLocalPath, action.path);
+      const entry = buildFileStateEntry({
+        remoteId: action.remoteId,
+        localHash: localEntry?.contentHash,
+        remoteHash: remoteEntry?.contentHash
+      });
+      return entry ? { removePath: action.fromPath, entryPath: action.path, entry } : { removePath: action.fromPath };
+    }
+    case "move_local_folder": {
+      const fromLocalPath = resolveLocalSyncPath(config.localRoot, action.fromPath);
+      const toLocalPath = resolveLocalSyncPath(config.localRoot, action.path);
+      await assertLocalPathHasNoSymlinks(config.localRoot, fromLocalPath);
+      await assertLocalPathHasNoSymlinks(config.localRoot, toLocalPath);
+      await fs6.mkdir(path7.dirname(toLocalPath), { recursive: true });
+      await assertLocalPathHasNoSymlinks(config.localRoot, toLocalPath);
+      await moveLocalDirectoryWithoutReplacing(fromLocalPath, toLocalPath, action.path, {
+        validateSource: () => assertLocalFolderMoveSourceStillMatches(
+          config.localRoot,
+          collectLocalSubtreeEntries(context.localEntries, action.fromPath),
+          action.fromPath
+        )
+      });
+      return { movePath: { fromPath: action.fromPath, path: action.path } };
+    }
+    case "download_file": {
+      const localPath = resolveLocalSyncPath(config.localRoot, action.path);
+      const remoteEntry = context.remoteEntries.get(action.path);
+      const localEntry = context.localEntries.get(action.path);
+      await assertLocalPathHasNoSymlinks(config.localRoot, localPath);
+      await assertRemoteFileAtPathStillMatches(client, config, remoteEntry, action);
+      const data = await client.downloadFile(action.remoteId);
+      await assertRemoteFileAtPathStillMatches(client, config, remoteEntry, action);
+      await writeFileAtomically(localPath, data, {
+        localRoot: config.localRoot,
+        replace: action.reason !== "remote_created",
+        expectedLocalHash: action.reason === "remote_changed" ? localEntry?.contentHash : null,
+        syncPath: action.path
+      });
+      const entry = buildFileStateEntry({
+        remoteId: action.remoteId,
+        localHash: crypto3.createHash("sha256").update(data).digest("hex"),
+        remoteHash: remoteEntry?.contentHash
+      });
+      return entry ? { entryPath: action.path, entry } : null;
+    }
+    case "delete_remote": {
+      const deleteTarget = await assertRemoteFileDeleteTargetStillMatches(
+        client,
+        config,
+        context.remoteEntries.get(action.path),
+        action
+      );
+      if (!deleteTarget.alreadyGone) {
+        await client.deleteRemoteFile(action.remoteId, {
+          expectedRevision: context.remoteEntries.get(action.path)?.revision
+        });
+      }
+      return { removePath: action.path };
+    }
+    case "delete_remote_folder": {
+      const deleteTarget = await assertRemoteFolderDeleteTargetStillMatches(
+        client,
+        config,
+        collectRemoteSubtreeEntries(context.remoteEntries, action.path),
+        action
+      );
+      if (!deleteTarget.alreadyGone) {
+        await client.deleteRemoteFolder(action.remoteId, {
+          expectedRevision: context.remoteEntries.get(action.path)?.revision
+        });
+      }
+      return { removePath: action.path };
+    }
+    case "delete_local": {
+      const localPath = resolveLocalSyncPath(config.localRoot, action.path);
+      await assertLocalPathHasNoSymlinks(config.localRoot, localPath);
+      await assertLocalDeleteTargetStillMatches(
+        localPath,
+        context.localEntries.get(action.path)?.contentHash,
+        action.path
+      );
+      await assertLocalPathHasNoSymlinks(config.localRoot, localPath);
+      await fs6.rm(localPath, {
+        force: true,
+        recursive: false
+      });
+      return { removePath: action.path };
+    }
+    case "delete_local_folder": {
+      const localPath = resolveLocalSyncPath(config.localRoot, action.path);
+      await assertLocalPathHasNoSymlinks(config.localRoot, localPath);
+      await assertLocalFolderDeleteTargetStillMatches(
+        config.localRoot,
+        collectLocalSubtreeEntries(context.localEntries, action.path),
+        action.path
+      );
+      await assertLocalPathHasNoSymlinks(config.localRoot, localPath);
+      await fs6.rm(localPath, {
+        force: true,
+        recursive: true
+      });
+      return { removePath: action.path };
+    }
+    case "conflict":
+      await writeConflictMarker(config.localRoot, action);
+      return null;
+    default:
+      throw new Error(`Unknown sync action: ${action.type}`);
+  }
+}
+async function loadDesktopConfig(configPath = getDefaultConfigPath()) {
+  const config = await readJsonFile(configPath, null);
+  if (!config) {
+    throw new Error(`ZergBox Desktop is not configured. Run "zergbox-desktop init" first. Missing: ${configPath}`);
+  }
+  return {
+    intervalSeconds: 30,
+    localRoot: getDefaultLocalRoot(),
+    ...config,
+    configPath,
+    statePath: config.statePath || getDefaultStatePath(config.localRoot || getDefaultLocalRoot())
+  };
+}
+async function runSyncOnce({
+  configPath = getDefaultConfigPath(),
+  config: providedConfig,
+  client: providedClient,
+  force = false
+} = {}) {
+  const config = providedConfig ? {
+    intervalSeconds: 30,
+    localRoot: getDefaultLocalRoot(),
+    ...providedConfig,
+    statePath: providedConfig.statePath || getDefaultStatePath(providedConfig.localRoot || getDefaultLocalRoot())
+  } : await loadDesktopConfig(configPath);
+  await assertSafeLocalRoot(config.localRoot);
+  await assertSafeStatePath(config.statePath);
+  await fs6.mkdir(config.localRoot, { recursive: true });
+  await assertLocalPathHasNoSymlinks(config.localRoot);
+  const runtimeStatus = await getDesktopRuntimeStatus({ localRoot: config.localRoot });
+  if (runtimeStatus.paused && !force) {
+    const lastSyncedAt = await getLastKnownSyncedAt(config);
+    await writeDesktopStatus({
+      localRoot: config.localRoot,
+      status: {
+        state: "paused",
+        actionCount: 0,
+        conflictCount: 0,
+        lastSyncedAt,
+        pauseReason: runtimeStatus.pauseReason,
+        pauseWarning: runtimeStatus.pauseWarning || null
+      }
+    });
+    return {
+      actions: [],
+      localRoot: config.localRoot,
+      statePath: config.statePath,
+      syncedAt: null,
+      paused: true,
+      pauseReason: runtimeStatus.pauseReason,
+      pauseWarning: runtimeStatus.pauseWarning || null,
+      locked: false
+    };
+  }
+  const lock = await acquireSyncLock({ localRoot: config.localRoot });
+  if (!lock.acquired) {
+    const lastSyncedAt = await getLastKnownSyncedAt(config);
+    await writeDesktopStatus({
+      localRoot: config.localRoot,
+      status: {
+        state: "locked",
+        actionCount: 0,
+        conflictCount: 0,
+        lastSyncedAt,
+        lockPath: lock.lockPath,
+        lockOwner: lock.owner || null
+      }
+    });
+    return {
+      actions: [],
+      localRoot: config.localRoot,
+      statePath: config.statePath,
+      syncedAt: null,
+      paused: false,
+      locked: true,
+      lockPath: lock.lockPath,
+      lockOwner: lock.owner || null
+    };
+  }
+  let plannedActions = [];
+  const completedActions = [];
+  let failedAction = null;
+  try {
+    const lastSyncedAt = await getLastKnownSyncedAt(config);
+    await writeDesktopStatus({
+      localRoot: config.localRoot,
+      status: {
+        state: "syncing",
+        actionCount: 0,
+        plannedActionCount: null,
+        conflictCount: 0,
+        lastSyncedAt,
+        currentAction: null,
+        errorMessage: null
+      }
+    });
+    const client = providedClient || new ZergBoxDesktopClient({
+      baseUrl: config.baseUrl,
+      token: config.token,
+      requestTimeoutMs: config.requestTimeoutMs
+    });
+    const state = await readJsonFile(config.statePath, { version: 1, entries: {} }, {
+      recoverInvalidJson: true,
+      assertSafePath: assertSafeStatePath
+    });
+    const localEntries = await scanLocalTree(config.localRoot);
+    const remoteTree = await fetchConfiguredRemoteTree(client, config);
+    const actions = planSync({ localEntries, remoteEntries: remoteTree.entries, state });
+    plannedActions = actions;
+    const incrementalState = cloneSyncState(state);
+    const context = {
+      rootFolder: remoteTree.rootFolder,
+      remoteFolders: indexRemoteFolders(remoteTree.rootFolder, remoteTree.entries),
+      localEntries: new Map(localEntries.map((entry) => [entry.path, entry])),
+      remoteEntries: new Map(remoteTree.entries.map((entry) => [entry.path, entry]))
+    };
+    for (const action of actions) {
+      await writeDesktopStatus({
+        localRoot: config.localRoot,
+        status: {
+          state: "syncing",
+          actionCount: completedActions.length,
+          plannedActionCount: actions.length,
+          conflictCount: countConflicts(completedActions),
+          lastSyncedAt,
+          currentAction: action,
+          errorMessage: null
+        }
+      });
+      failedAction = action;
+      let mutation;
+      try {
+        mutation = await applyAction(client, config, context, action);
+      } catch (error) {
+        if (!(error instanceof ZergBoxSyncConflictError)) {
+          throw error;
+        }
+        const conflictAction = {
+          type: "conflict",
+          path: action.path,
+          fromPath: action.fromPath,
+          remoteId: action.remoteId,
+          reason: "remote_write_conflict",
+          expectedRevision: error.expectedRevision,
+          status: error.status
+        };
+        await writeConflictMarker(config.localRoot, conflictAction);
+        completedActions.push(conflictAction);
+        failedAction = null;
+        continue;
+      }
+      if (applyStateMutation(incrementalState, mutation, (/* @__PURE__ */ new Date()).toISOString())) {
+        await writeJsonFile(config.statePath, incrementalState, { assertSafePath: assertSafeStatePath });
+      }
+      completedActions.push(action);
+      failedAction = null;
+    }
+    const finalLocalEntries = await scanLocalTree(config.localRoot);
+    const finalRemoteTree = await fetchConfiguredRemoteTree(client, config);
+    const conflictActions = completedActions.filter((action) => action.type === "conflict");
+    const unresolvedConflictPaths = new Set(conflictActions.map((action) => action.path));
+    const conflictCount = countConflicts(completedActions);
+    const nextState = buildStableFinalSyncState(finalLocalEntries, finalRemoteTree.entries, (/* @__PURE__ */ new Date()).toISOString(), {
+      baselineLocalEntries: localEntries,
+      baselineRemoteEntries: remoteTree.entries,
+      incrementalState,
+      skipPaths: unresolvedConflictPaths
+    });
+    await pruneResolvedConflictMarkers(config.localRoot, conflictActions);
+    await writeJsonFile(config.statePath, nextState, { assertSafePath: assertSafeStatePath });
+    await writeDesktopStatus({
+      localRoot: config.localRoot,
+      status: {
+        state: conflictCount > 0 ? "conflicted" : "synced",
+        actionCount: completedActions.length,
+        conflictCount,
+        lastSyncedAt: nextState.syncedAt,
+        currentAction: null,
+        errorMessage: null
+      }
+    });
+    return {
+      actions: completedActions,
+      localRoot: config.localRoot,
+      statePath: config.statePath,
+      syncedAt: nextState.syncedAt,
+      paused: false,
+      locked: false
+    };
+  } catch (error) {
+    const lastSyncedAt = await getLastKnownSyncedAt(config);
+    await writeDesktopStatus({
+      localRoot: config.localRoot,
+      status: {
+        state: "error",
+        actionCount: completedActions.length,
+        plannedActionCount: plannedActions.length,
+        conflictCount: countConflicts(completedActions),
+        lastSyncedAt,
+        currentAction: null,
+        failedAction,
+        errorMessage: error.message
+      }
+    });
+    throw error;
+  } finally {
+    await lock.release();
+  }
+}
+
+// src/sync.mjs
+var DEFAULT_INTERVAL_MS = 3e4;
+var DEFAULT_DEBOUNCE_MS = 1e3;
+function createSyncSession(options = {}) {
+  const config = normalizeSessionOptions(options);
+  let scheduler = null;
+  let folderWatcher = null;
+  let watching = false;
+  let closed = false;
+  let readyPromise = null;
+  function ensureOpen() {
+    if (closed) {
+      throw new Error("ZergBox sync session is closed");
+    }
+  }
+  function ensureReady() {
+    if (!readyPromise) {
+      readyPromise = (async () => {
+        await assertSafeLocalRoot(config.localRoot);
+        await assertSafeStatePath(config.statePath);
+        await fs7.mkdir(config.localRoot, { recursive: true });
+        await fs7.mkdir(path8.dirname(config.statePath), { recursive: true });
+        await assertSafeStatePath(config.statePath);
+      })();
+    }
+    return readyPromise;
+  }
+  async function resolveClient() {
+    if (config.client) {
+      return config.client;
+    }
+    const providedToken = await config.tokenProvider();
+    const token = typeof providedToken === "string" ? providedToken : providedToken?.token;
+    if (typeof token !== "string" || token.trim() === "") {
+      throw new Error("tokenProvider must return a non-empty token");
+    }
+    return new ZergBoxDesktopClient({
+      baseUrl: config.baseUrl,
+      token,
+      requestTimeoutMs: config.requestTimeoutMs
+    });
+  }
+  async function syncOnce({ force = false } = {}) {
+    ensureOpen();
+    await ensureReady();
+    const result = await runSyncOnce({
+      config: {
+        organizationId: config.organizationId,
+        rootFolderId: config.rootFolderId,
+        localRoot: config.localRoot,
+        statePath: config.statePath,
+        requestTimeoutMs: config.requestTimeoutMs
+      },
+      client: await resolveClient(),
+      force
+    });
+    await config.afterSync(result);
+    return result;
+  }
+  async function status() {
+    await ensureReady();
+    const runtimeStatus = await getDesktopRuntimeStatus({ localRoot: config.localRoot });
+    const desktopStatus = await readDesktopStatus({ localRoot: config.localRoot });
+    return {
+      state: runtimeStatus.paused ? "paused" : desktopStatus?.state || (closed ? "closed" : "idle"),
+      paused: runtimeStatus.paused,
+      watching,
+      closed,
+      deviceId: config.deviceId,
+      organizationId: config.organizationId,
+      rootFolderId: config.rootFolderId,
+      localRoot: config.localRoot,
+      statePath: config.statePath,
+      lastSyncedAt: desktopStatus?.lastSyncedAt || null,
+      actionCount: desktopStatus?.actionCount ?? null,
+      conflictCount: desktopStatus?.conflictCount ?? null,
+      errorMessage: desktopStatus?.errorMessage || null,
+      pauseReason: runtimeStatus.pauseReason,
+      pauseWarning: runtimeStatus.pauseWarning
+    };
+  }
+  async function watch({ immediate = true } = {}) {
+    ensureOpen();
+    await ensureReady();
+    if (watching) {
+      return status();
+    }
+    scheduler = new SyncScheduler({
+      debounceMs: config.debounceMs,
+      intervalMs: config.intervalMs,
+      onError: config.onError,
+      runOnce: () => syncOnce()
+    });
+    try {
+      folderWatcher = watchFileSystem(
+        config.localRoot,
+        { recursive: process.platform === "darwin" || process.platform === "win32" },
+        (_eventType, filename) => {
+          const changedPath = normalizeSyncPath(filename || "");
+          if (changedPath && isSyncPathIgnored(changedPath)) {
+            return;
+          }
+          scheduler?.trigger("local-change");
+        }
+      );
+    } catch (error) {
+      config.onError(error);
+    }
+    watching = true;
+    scheduler.start({ immediate });
+    return status();
+  }
+  async function pause(reason = "Paused by user") {
+    ensureOpen();
+    await ensureReady();
+    await pauseDesktopSync({ localRoot: config.localRoot, reason });
+    return status();
+  }
+  async function resume() {
+    ensureOpen();
+    await ensureReady();
+    await resumeDesktopSync({ localRoot: config.localRoot });
+    return status();
+  }
+  async function stopWatchingResources() {
+    const activeScheduler = scheduler;
+    scheduler = null;
+    const idle = activeScheduler?.stop();
+    folderWatcher?.close();
+    folderWatcher = null;
+    watching = false;
+    await idle;
+  }
+  async function stopWatching() {
+    ensureOpen();
+    await stopWatchingResources();
+    return status();
+  }
+  async function close() {
+    if (!closed) {
+      closed = true;
+      await stopWatchingResources();
+    }
+    return status();
+  }
+  return {
+    syncOnce,
+    watch,
+    status,
+    pause,
+    resume,
+    stopWatching,
+    close
+  };
+}
+function normalizeSessionOptions(options) {
+  for (const name of ["organizationId", "rootFolderId", "localRoot", "deviceId"]) {
+    if (typeof options[name] !== "string" || options[name].trim() === "") {
+      throw new Error(`${name} is required`);
+    }
+  }
+  if (!options.client) {
+    if (typeof options.baseUrl !== "string" || options.baseUrl.trim() === "") {
+      throw new Error("baseUrl is required when client is not provided");
+    }
+    if (typeof options.tokenProvider !== "function") {
+      throw new Error("tokenProvider is required when client is not provided");
+    }
+  }
+  if (options.afterSync !== void 0 && typeof options.afterSync !== "function") {
+    throw new Error("afterSync must be a function");
+  }
+  return {
+    ...options,
+    localRoot: path8.resolve(options.localRoot),
+    statePath: path8.resolve(
+      options.statePath || path8.join(options.localRoot, ".zergbox-desktop", "state.json")
+    ),
+    intervalMs: normalizeNonNegativeNumber(options.intervalMs, DEFAULT_INTERVAL_MS),
+    debounceMs: normalizeNonNegativeNumber(options.debounceMs, DEFAULT_DEBOUNCE_MS),
+    onError: typeof options.onError === "function" ? options.onError : console.error,
+    afterSync: options.afterSync || (async () => {
+    })
+  };
+}
+function normalizeNonNegativeNumber(value, fallback) {
+  const parsed = Number(value ?? fallback);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.trunc(parsed) : fallback;
+}
+export {
+  MERGE_CANDIDATE_STATES,
+  SYNC_CHANGE_TYPES,
+  SYNC_NODE_TYPES,
+  createSyncSession,
+  isMergeCandidate,
+  isSyncChange,
+  isSyncNode
+};