@zergai/zergbox-client 0.1.0

package/dist/chunk-KLBU4HNA.js

@@ -0,0 +1,1311 @@
+// ../desktop/src/sync-planner.mjs
+var DEFAULT_IGNORE_PATTERNS = [
+  ".zergbox-desktop",
+  ".zergbox-desktop/**",
+  "*.zergbox-download",
+  ".DS_Store",
+  "Thumbs.db",
+  "desktop.ini"
+];
+var ACTION_PRIORITY = {
+  create_remote_folder: 10,
+  move_remote_folder: 15,
+  upload_file: 20,
+  move_remote_file: 25,
+  create_local_folder: 30,
+  move_local_folder: 35,
+  download_file: 40,
+  move_local_file: 45,
+  conflict: 50,
+  delete_remote: 60,
+  delete_remote_folder: 61,
+  delete_local: 70,
+  delete_local_folder: 71
+};
+var WINDOWS_RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  "COM1",
+  "COM2",
+  "COM3",
+  "COM4",
+  "COM5",
+  "COM6",
+  "COM7",
+  "COM8",
+  "COM9",
+  "LPT1",
+  "LPT2",
+  "LPT3",
+  "LPT4",
+  "LPT5",
+  "LPT6",
+  "LPT7",
+  "LPT8",
+  "LPT9"
+]);
+function normalizeSyncPath(input) {
+  return String(input || "").replaceAll("\\", "/").split("/").filter((part) => part && part !== ".").join("/");
+}
+function isPortableSyncName(value) {
+  if (typeof value !== "string" || value.length < 1 || value.length > 255) {
+    return false;
+  }
+  if (value !== value.trim()) {
+    return false;
+  }
+  if (value === "." || value === "..") {
+    return false;
+  }
+  if (/[\u0000-\u001F\u007F]/.test(value)) {
+    return false;
+  }
+  if (/[<>:"\\|?*]/.test(value)) {
+    return false;
+  }
+  if (/[. ]$/.test(value)) {
+    return false;
+  }
+  return !WINDOWS_RESERVED_NAMES.has(value.split(".")[0].toUpperCase());
+}
+function hasSafePortableSegments(normalizedPath) {
+  return normalizedPath.split("/").every(isPortableSyncName);
+}
+function isSafeSyncPath(input) {
+  const rawPath = String(input || "");
+  const traversalPath = rawPath.replaceAll("\\", "/");
+  const normalizedPath = normalizeSyncPath(rawPath);
+  return Boolean(normalizedPath) && !rawPath.includes("\\") && !traversalPath.startsWith("/") && !traversalPath.split("/").some((part) => part === "..") && hasSafePortableSegments(normalizedPath);
+}
+function isSyncPathIgnored(path2, ignorePatterns = DEFAULT_IGNORE_PATTERNS) {
+  return ignorePatterns.some((pattern) => {
+    if (pattern.endsWith("/**")) {
+      const prefix = pattern.slice(0, -3);
+      return path2 === prefix || path2.startsWith(`${prefix}/`);
+    }
+    if (pattern.startsWith("*")) {
+      return path2.endsWith(pattern.slice(1));
+    }
+    return path2 === pattern || path2.endsWith(`/${pattern}`);
+  });
+}
+function caseFoldSyncPath(syncPath) {
+  return normalizeSyncPath(syncPath).toLowerCase();
+}
+function collectCaseCollisionData(entries, ignorePatterns, includeRemoteIds = false) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries || []) {
+    const rawPath = String(entry.path || "");
+    const normalizedPath = normalizeSyncPath(rawPath);
+    if (!normalizedPath || !isSafeSyncPath(rawPath) || isSyncPathIgnored(normalizedPath, ignorePatterns)) {
+      continue;
+    }
+    const caseKey = caseFoldSyncPath(normalizedPath);
+    const group = groups.get(caseKey) || [];
+    group.push({ entry, path: normalizedPath });
+    groups.set(caseKey, group);
+  }
+  const keys = /* @__PURE__ */ new Set();
+  const actions = [];
+  for (const [caseKey, group] of groups) {
+    if (group.length < 2) {
+      continue;
+    }
+    keys.add(caseKey);
+    for (const item of group) {
+      const action = {
+        type: "conflict",
+        path: item.path,
+        reason: "case_collision"
+      };
+      if (includeRemoteIds && item.entry.id) {
+        action.remoteId = item.entry.id;
+      }
+      actions.push(action);
+    }
+  }
+  return { keys, actions };
+}
+function groupEntriesByCaseKey(entries, ignorePatterns) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries || []) {
+    const rawPath = String(entry.path || "");
+    const normalizedPath = normalizeSyncPath(rawPath);
+    if (!normalizedPath || !isSafeSyncPath(rawPath) || isSyncPathIgnored(normalizedPath, ignorePatterns)) {
+      continue;
+    }
+    const caseKey = caseFoldSyncPath(normalizedPath);
+    const group = groups.get(caseKey) || [];
+    group.push({ entry, path: normalizedPath });
+    groups.set(caseKey, group);
+  }
+  return groups;
+}
+function collectCrossCaseCollisionData(localEntries, remoteEntries, ignorePatterns, excludedCaseKeys = /* @__PURE__ */ new Set()) {
+  const localGroups = groupEntriesByCaseKey(localEntries, ignorePatterns);
+  const remoteGroups = groupEntriesByCaseKey(remoteEntries, ignorePatterns);
+  const keys = /* @__PURE__ */ new Set();
+  const actions = [];
+  for (const [caseKey, localGroup] of localGroups) {
+    if (excludedCaseKeys.has(caseKey) || !remoteGroups.has(caseKey)) {
+      continue;
+    }
+    const remoteGroup = remoteGroups.get(caseKey);
+    const hasCaseMismatch = localGroup.some((localItem) => {
+      return remoteGroup.some((remoteItem) => localItem.path !== remoteItem.path);
+    });
+    if (!hasCaseMismatch) {
+      continue;
+    }
+    keys.add(caseKey);
+    for (const item of localGroup) {
+      actions.push({
+        type: "conflict",
+        path: item.path,
+        reason: "case_collision"
+      });
+    }
+    for (const item of remoteGroup) {
+      const action = {
+        type: "conflict",
+        path: item.path,
+        reason: "case_collision"
+      };
+      if (item.entry.id) {
+        action.remoteId = item.entry.id;
+      }
+      actions.push(action);
+    }
+  }
+  return { keys, actions };
+}
+function expandDescendantCaseKeys(excludedCaseKeys, entries, ignorePatterns) {
+  const parentCaseKeys = Array.from(excludedCaseKeys);
+  if (parentCaseKeys.length === 0) {
+    return new Set(excludedCaseKeys);
+  }
+  const expanded = new Set(excludedCaseKeys);
+  for (const entry of entries || []) {
+    const rawPath = String(entry.path || entry || "");
+    const normalizedPath = normalizeSyncPath(rawPath);
+    if (!normalizedPath || !isSafeSyncPath(rawPath) || isSyncPathIgnored(normalizedPath, ignorePatterns)) {
+      continue;
+    }
+    const caseKey = caseFoldSyncPath(normalizedPath);
+    if (parentCaseKeys.some((parentCaseKey) => caseKey.startsWith(`${parentCaseKey}/`))) {
+      expanded.add(caseKey);
+    }
+  }
+  return expanded;
+}
+function indexEntries(entries, ignorePatterns, excludedCaseKeys = /* @__PURE__ */ new Set()) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries || []) {
+    const rawPath = String(entry.path || "");
+    const normalizedPath = normalizeSyncPath(rawPath);
+    if (!normalizedPath || !isSafeSyncPath(rawPath) || isSyncPathIgnored(normalizedPath, ignorePatterns) || excludedCaseKeys.has(caseFoldSyncPath(normalizedPath))) {
+      continue;
+    }
+    map.set(normalizedPath, {
+      ...entry,
+      path: normalizedPath,
+      type: entry.type === "directory" ? "directory" : "file"
+    });
+  }
+  return map;
+}
+function collectUnsupportedLocalActions(entries, ignorePatterns) {
+  const unsupported = [];
+  const unsupportedPaths = [];
+  for (const entry of entries || []) {
+    const rawPath = String(entry.path || "");
+    const normalizedPath = normalizeSyncPath(rawPath);
+    if (!normalizedPath || isSyncPathIgnored(normalizedPath, ignorePatterns)) {
+      continue;
+    }
+    if (isSafeSyncPath(rawPath)) {
+      continue;
+    }
+    if (unsupportedPaths.some((parentPath) => normalizedPath.startsWith(`${parentPath}/`))) {
+      continue;
+    }
+    unsupported.push({
+      type: "conflict",
+      path: rawPath,
+      reason: "unsupported_local_name"
+    });
+    if (entry.type === "directory") {
+      unsupportedPaths.push(normalizedPath);
+    }
+  }
+  return unsupported;
+}
+function collectUnsupportedRemoteActions(entries, ignorePatterns) {
+  const unsupported = [];
+  const unsupportedPaths = [];
+  for (const entry of entries || []) {
+    const rawPath = String(entry.path || "");
+    const normalizedPath = normalizeSyncPath(rawPath);
+    if (!normalizedPath || isSyncPathIgnored(normalizedPath, ignorePatterns)) {
+      continue;
+    }
+    if (isSafeSyncPath(rawPath)) {
+      continue;
+    }
+    if (unsupportedPaths.some((parentPath) => normalizedPath.startsWith(`${parentPath}/`))) {
+      continue;
+    }
+    unsupported.push(addRemoteId({
+      type: "conflict",
+      path: rawPath,
+      reason: "unsupported_remote_name"
+    }, entry, null));
+    if (entry.type === "directory") {
+      unsupportedPaths.push(normalizedPath);
+    }
+  }
+  return unsupported;
+}
+function getRemoteId(remoteEntry, stateEntry) {
+  return remoteEntry?.id || stateEntry?.remoteId;
+}
+function addRemoteId(action, remoteEntry, stateEntry) {
+  const remoteId = getRemoteId(remoteEntry, stateEntry);
+  return remoteId ? { ...action, remoteId } : action;
+}
+function hasLocalChanged(localEntry, stateEntry) {
+  if (!stateEntry) {
+    return false;
+  }
+  return localEntry?.contentHash !== stateEntry.localHash;
+}
+function hasRemoteChanged(remoteEntry, stateEntry) {
+  if (!stateEntry) {
+    return false;
+  }
+  return remoteEntry?.contentHash !== stateEntry.remoteHash;
+}
+function planBothPresent(path2, localEntry, remoteEntry, stateEntry) {
+  if (localEntry.type !== remoteEntry.type) {
+    return addRemoteId({ type: "conflict", path: path2, reason: "type_mismatch" }, remoteEntry, stateEntry);
+  }
+  if (localEntry.type === "directory") {
+    return null;
+  }
+  if (!stateEntry) {
+    if (localEntry.contentHash === remoteEntry.contentHash) {
+      return null;
+    }
+    return addRemoteId({ type: "conflict", path: path2, reason: "untracked_divergence" }, remoteEntry, stateEntry);
+  }
+  const localChanged = hasLocalChanged(localEntry, stateEntry);
+  const remoteChanged = hasRemoteChanged(remoteEntry, stateEntry);
+  if (localChanged && remoteChanged) {
+    if (localEntry.contentHash === remoteEntry.contentHash) {
+      return null;
+    }
+    return addRemoteId({ type: "conflict", path: path2, reason: "both_changed" }, remoteEntry, stateEntry);
+  }
+  if (localChanged) {
+    return addRemoteId({ type: "upload_file", path: path2, reason: "local_changed" }, remoteEntry, stateEntry);
+  }
+  if (remoteChanged) {
+    return addRemoteId({ type: "download_file", path: path2, reason: "remote_changed" }, remoteEntry, stateEntry);
+  }
+  return null;
+}
+function planLocalOnly(path2, localEntry, stateEntry) {
+  if (!stateEntry) {
+    return {
+      type: localEntry.type === "directory" ? "create_remote_folder" : "upload_file",
+      path: path2,
+      reason: "local_created"
+    };
+  }
+  if (localEntry.type === "directory") {
+    return addRemoteId({ type: "delete_local_folder", path: path2, reason: "remote_deleted" }, null, stateEntry);
+  }
+  const localChanged = hasLocalChanged(localEntry, stateEntry);
+  if (localChanged) {
+    return addRemoteId({ type: "conflict", path: path2, reason: "remote_deleted_local_changed" }, null, stateEntry);
+  }
+  return addRemoteId({ type: "delete_local", path: path2, reason: "remote_deleted" }, null, stateEntry);
+}
+function planRemoteOnly(path2, remoteEntry, stateEntry) {
+  if (!stateEntry) {
+    return addRemoteId(
+      {
+        type: remoteEntry.type === "directory" ? "create_local_folder" : "download_file",
+        path: path2,
+        reason: "remote_created"
+      },
+      remoteEntry,
+      stateEntry
+    );
+  }
+  if (remoteEntry.type === "directory") {
+    return addRemoteId({ type: "delete_remote_folder", path: path2, reason: "local_deleted" }, remoteEntry, stateEntry);
+  }
+  const remoteChanged = hasRemoteChanged(remoteEntry, stateEntry);
+  if (remoteChanged) {
+    return addRemoteId({ type: "conflict", path: path2, reason: "local_deleted_remote_changed" }, remoteEntry, stateEntry);
+  }
+  return addRemoteId({ type: "delete_remote", path: path2, reason: "local_deleted" }, remoteEntry, stateEntry);
+}
+function isFileStateEntry(stateEntry) {
+  return stateEntry?.type === "file" || stateEntry?.localHash && stateEntry?.remoteHash;
+}
+function isDirectoryStateEntry(stateEntry) {
+  return stateEntry?.type === "directory";
+}
+function stableRemoteContentFingerprint(contentHash) {
+  const parts = String(contentHash || "").split(":");
+  if (parts.length < 3) {
+    return null;
+  }
+  return parts.slice(0, 2).join(":");
+}
+function hasSameRemoteFileContent(remoteEntry, stateEntry) {
+  if (!remoteEntry?.contentHash || !stateEntry?.remoteHash) {
+    return false;
+  }
+  if (remoteEntry.contentHash === stateEntry.remoteHash) {
+    return true;
+  }
+  const currentStable = stableRemoteContentFingerprint(remoteEntry.contentHash);
+  const previousStable = stableRemoteContentFingerprint(stateEntry.remoteHash);
+  return Boolean(currentStable && previousStable && currentStable === previousStable);
+}
+function collectLocalCreatedFileCandidates(localByPath, remoteByPath, stateEntries) {
+  const candidatesByHash = /* @__PURE__ */ new Map();
+  for (const [path2, entry] of localByPath) {
+    if (entry.type !== "file" || !entry.contentHash || remoteByPath.has(path2) || stateEntries.has(path2)) {
+      continue;
+    }
+    const candidates = candidatesByHash.get(entry.contentHash) || [];
+    candidates.push({ path: path2, entry });
+    candidatesByHash.set(entry.contentHash, candidates);
+  }
+  return candidatesByHash;
+}
+function collectRemoteCreatedFileCandidates(remoteByPath, localByPath, stateEntries) {
+  const candidatesByRemoteId = /* @__PURE__ */ new Map();
+  for (const [path2, entry] of remoteByPath) {
+    if (entry.type !== "file" || !entry.id || localByPath.has(path2) || stateEntries.has(path2)) {
+      continue;
+    }
+    const candidates = candidatesByRemoteId.get(entry.id) || [];
+    candidates.push({ path: path2, entry });
+    candidatesByRemoteId.set(entry.id, candidates);
+  }
+  return candidatesByRemoteId;
+}
+function collectLocalCreatedFolderCandidates(localByPath, remoteByPath, stateEntries) {
+  const candidates = [];
+  for (const [path2, entry] of localByPath) {
+    if (entry.type === "directory" && !remoteByPath.has(path2) && !stateEntries.has(path2)) {
+      candidates.push({ path: path2, entry });
+    }
+  }
+  return candidates;
+}
+function collectRemoteCreatedFolderCandidates(remoteByPath, localByPath, stateEntries) {
+  const candidatesByRemoteId = /* @__PURE__ */ new Map();
+  for (const [path2, entry] of remoteByPath) {
+    if (entry.type !== "directory" || !entry.id || localByPath.has(path2) || stateEntries.has(path2)) {
+      continue;
+    }
+    const candidates = candidatesByRemoteId.get(entry.id) || [];
+    candidates.push({ path: path2, entry });
+    candidatesByRemoteId.set(entry.id, candidates);
+  }
+  return candidatesByRemoteId;
+}
+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 localSubtreeMatchesState(fromPath, toPath, stateEntries, localByPath) {
+  let matched = false;
+  for (const [statePath, stateEntry] of stateEntries) {
+    if (!pathIsWithin(statePath, fromPath)) {
+      continue;
+    }
+    matched = true;
+    const localEntry = localByPath.get(replacePathPrefix(statePath, fromPath, toPath));
+    if (!localEntry || localEntry.type !== (stateEntry.type === "directory" ? "directory" : "file")) {
+      return false;
+    }
+    if (localEntry.type === "file" && localEntry.contentHash !== stateEntry.localHash) {
+      return false;
+    }
+  }
+  return matched;
+}
+function remoteSubtreeMatchesState(fromPath, toPath, stateEntries, remoteByPath) {
+  let matched = false;
+  for (const [statePath, stateEntry] of stateEntries) {
+    if (!pathIsWithin(statePath, fromPath)) {
+      continue;
+    }
+    matched = true;
+    const remoteEntry = remoteByPath.get(replacePathPrefix(statePath, fromPath, toPath));
+    if (!remoteEntry || remoteEntry.type !== (stateEntry.type === "directory" ? "directory" : "file")) {
+      return false;
+    }
+    if (stateEntry.remoteId && remoteEntry.id !== stateEntry.remoteId) {
+      return false;
+    }
+    if (remoteEntry.type === "file" && !hasSameRemoteFileContent(remoteEntry, stateEntry)) {
+      return false;
+    }
+  }
+  return matched;
+}
+function collectFolderMoveActions(localByPath, remoteByPath, stateEntries) {
+  const localCreatedFolders = collectLocalCreatedFolderCandidates(localByPath, remoteByPath, stateEntries);
+  const remoteCreatedFoldersById = collectRemoteCreatedFolderCandidates(remoteByPath, localByPath, stateEntries);
+  const localMoveCandidates = [];
+  const remoteMoveCandidates = [];
+  for (const [fromPath, stateEntry] of stateEntries) {
+    if (!isDirectoryStateEntry(stateEntry) || !stateEntry.remoteId) {
+      continue;
+    }
+    const localEntry = localByPath.get(fromPath);
+    const remoteEntry = remoteByPath.get(fromPath);
+    if (!localEntry && remoteEntry?.type === "directory" && remoteEntry.id === stateEntry.remoteId && remoteSubtreeMatchesState(fromPath, fromPath, stateEntries, remoteByPath)) {
+      const candidates = localCreatedFolders.filter((candidate) => {
+        return localSubtreeMatchesState(fromPath, candidate.path, stateEntries, localByPath);
+      });
+      if (candidates.length === 1) {
+        localMoveCandidates.push({
+          fromPath,
+          path: candidates[0].path,
+          remoteEntry
+        });
+      }
+    }
+    if (localEntry?.type === "directory" && !remoteEntry && localSubtreeMatchesState(fromPath, fromPath, stateEntries, localByPath)) {
+      const candidates = (remoteCreatedFoldersById.get(stateEntry.remoteId) || []).filter((candidate) => {
+        return remoteSubtreeMatchesState(fromPath, candidate.path, stateEntries, remoteByPath);
+      });
+      if (candidates.length === 1) {
+        remoteMoveCandidates.push({
+          fromPath,
+          path: candidates[0].path,
+          remoteEntry: candidates[0].entry
+        });
+      }
+    }
+  }
+  return [
+    ...compactFolderMoveCandidates(resolveUniqueMoveCandidates(localMoveCandidates)).map((candidate) => ({
+      type: "move_remote_folder",
+      fromPath: candidate.fromPath,
+      path: candidate.path,
+      reason: "local_moved",
+      remoteId: candidate.remoteEntry.id
+    })),
+    ...compactFolderMoveCandidates(resolveUniqueMoveCandidates(remoteMoveCandidates)).map((candidate) => ({
+      type: "move_local_folder",
+      fromPath: candidate.fromPath,
+      path: candidate.path,
+      reason: "remote_moved",
+      remoteId: candidate.remoteEntry.id
+    }))
+  ];
+}
+function compactFolderMoveCandidates(candidates) {
+  return candidates.filter((candidate) => {
+    return !candidates.some((parentCandidate) => {
+      return parentCandidate !== candidate && pathIsWithin(candidate.fromPath, parentCandidate.fromPath) && pathIsWithin(candidate.path, parentCandidate.path);
+    });
+  });
+}
+function collectMovedStatePaths(moveActions, stateEntries) {
+  const movedPaths = /* @__PURE__ */ new Set();
+  for (const action of moveActions) {
+    movedPaths.add(action.fromPath);
+    movedPaths.add(action.path);
+    for (const statePath of stateEntries.keys()) {
+      if (!pathIsWithin(statePath, action.fromPath)) {
+        continue;
+      }
+      movedPaths.add(statePath);
+      movedPaths.add(replacePathPrefix(statePath, action.fromPath, action.path));
+    }
+  }
+  return movedPaths;
+}
+function collectFileMoveActions(localByPath, remoteByPath, stateEntries, excludedPaths = /* @__PURE__ */ new Set()) {
+  const localCreatedByHash = collectLocalCreatedFileCandidates(localByPath, remoteByPath, stateEntries);
+  const remoteCreatedById = collectRemoteCreatedFileCandidates(remoteByPath, localByPath, stateEntries);
+  const localMoveCandidates = [];
+  const remoteMoveCandidates = [];
+  for (const [fromPath, stateEntry] of stateEntries) {
+    if (!isFileStateEntry(stateEntry) || excludedPaths.has(fromPath)) {
+      continue;
+    }
+    const localEntry = localByPath.get(fromPath);
+    const remoteEntry = remoteByPath.get(fromPath);
+    if (!localEntry && remoteEntry?.type === "file" && hasSameRemoteFileContent(remoteEntry, stateEntry)) {
+      const candidates = localCreatedByHash.get(stateEntry.localHash) || [];
+      const availableCandidates = candidates.filter((candidate) => !excludedPaths.has(candidate.path));
+      if (availableCandidates.length === 1) {
+        localMoveCandidates.push({
+          fromPath,
+          path: availableCandidates[0].path,
+          remoteEntry
+        });
+      }
+    }
+    if (localEntry?.type === "file" && localEntry.contentHash === stateEntry.localHash && !remoteEntry && stateEntry.remoteId) {
+      const candidates = remoteCreatedById.get(stateEntry.remoteId) || [];
+      const availableCandidates = candidates.filter((candidate) => !excludedPaths.has(candidate.path));
+      if (availableCandidates.length === 1 && hasSameRemoteFileContent(availableCandidates[0].entry, stateEntry)) {
+        remoteMoveCandidates.push({
+          fromPath,
+          path: availableCandidates[0].path,
+          remoteEntry: availableCandidates[0].entry
+        });
+      }
+    }
+  }
+  return [
+    ...resolveUniqueMoveCandidates(localMoveCandidates).map((candidate) => ({
+      type: "move_remote_file",
+      fromPath: candidate.fromPath,
+      path: candidate.path,
+      reason: "local_moved",
+      remoteId: candidate.remoteEntry.id
+    })),
+    ...resolveUniqueMoveCandidates(remoteMoveCandidates).map((candidate) => ({
+      type: "move_local_file",
+      fromPath: candidate.fromPath,
+      path: candidate.path,
+      reason: "remote_moved",
+      remoteId: candidate.remoteEntry.id
+    }))
+  ];
+}
+function resolveUniqueMoveCandidates(candidates) {
+  const fromPathCounts = countBy(candidates, (candidate) => candidate.fromPath);
+  const pathCounts = countBy(candidates, (candidate) => candidate.path);
+  return candidates.filter((candidate) => {
+    return fromPathCounts.get(candidate.fromPath) === 1 && pathCounts.get(candidate.path) === 1;
+  });
+}
+function countBy(items, getKey) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = getKey(item);
+    counts.set(key, (counts.get(key) || 0) + 1);
+  }
+  return counts;
+}
+function isDescendantPath(path2, parentPath) {
+  return path2.startsWith(`${parentPath}/`);
+}
+function isDeleteActionCoveredByFolderDelete(action, folderDeleteAction) {
+  if (!isDescendantPath(action.path, folderDeleteAction.path)) {
+    return false;
+  }
+  if (folderDeleteAction.type === "delete_remote_folder") {
+    return action.type === "delete_remote" || action.type === "delete_remote_folder";
+  }
+  if (folderDeleteAction.type === "delete_local_folder") {
+    return action.type === "delete_local" || action.type === "delete_local_folder";
+  }
+  return false;
+}
+function compactRecursiveDeleteActions(actions) {
+  const folderDeletes = actions.filter((action) => {
+    return action.type === "delete_remote_folder" || action.type === "delete_local_folder";
+  });
+  const blockedFolderDeletes = new Set(
+    folderDeletes.filter((folderDelete) => {
+      return actions.some((action) => {
+        return action.type === "conflict" && isDescendantPath(action.path, folderDelete.path);
+      });
+    }).map((action) => `${action.type}:${action.path}`)
+  );
+  const activeFolderDeletes = folderDeletes.filter((action) => {
+    return !blockedFolderDeletes.has(`${action.type}:${action.path}`);
+  });
+  return actions.filter((action) => {
+    if (blockedFolderDeletes.has(`${action.type}:${action.path}`)) {
+      return false;
+    }
+    return !activeFolderDeletes.some((folderDelete) => {
+      return folderDelete !== action && isDeleteActionCoveredByFolderDelete(action, folderDelete);
+    });
+  });
+}
+function convertCreatedDescendantsUnderDeletedFolders(actions) {
+  const folderDeletes = actions.filter((action) => {
+    return action.type === "delete_remote_folder" || action.type === "delete_local_folder";
+  });
+  return actions.map((action) => {
+    if (action.reason !== "local_created" && action.reason !== "remote_created") {
+      return action;
+    }
+    const deletedParent = folderDeletes.find((folderDelete) => {
+      return isDescendantPath(action.path, folderDelete.path);
+    });
+    if (!deletedParent) {
+      return action;
+    }
+    if (deletedParent.type === "delete_local_folder" && action.reason === "local_created") {
+      return {
+        type: "conflict",
+        path: action.path,
+        reason: "remote_deleted_local_created"
+      };
+    }
+    if (deletedParent.type === "delete_remote_folder" && action.reason === "remote_created") {
+      return addRemoteId({
+        type: "conflict",
+        path: action.path,
+        reason: "local_deleted_remote_created"
+      }, null, action);
+    }
+    return action;
+  });
+}
+function planSync({ localEntries = [], remoteEntries = [], state = {}, ignorePatterns = DEFAULT_IGNORE_PATTERNS } = {}) {
+  const localCaseCollisions = collectCaseCollisionData(localEntries, ignorePatterns);
+  const remoteCaseCollisions = collectCaseCollisionData(remoteEntries, ignorePatterns, true);
+  const oneSidedCollisionKeys = /* @__PURE__ */ new Set([
+    ...localCaseCollisions.keys,
+    ...remoteCaseCollisions.keys
+  ]);
+  const crossCaseCollisions = collectCrossCaseCollisionData(
+    localEntries,
+    remoteEntries,
+    ignorePatterns,
+    oneSidedCollisionKeys
+  );
+  const excludedCaseKeys = /* @__PURE__ */ new Set([
+    ...oneSidedCollisionKeys,
+    ...crossCaseCollisions.keys
+  ]);
+  const statePaths = Object.keys(state.entries || {});
+  const expandedExcludedCaseKeys = expandDescendantCaseKeys(
+    expandDescendantCaseKeys(
+      expandDescendantCaseKeys(excludedCaseKeys, localEntries, ignorePatterns),
+      remoteEntries,
+      ignorePatterns
+    ),
+    statePaths,
+    ignorePatterns
+  );
+  const localByPath = indexEntries(localEntries, ignorePatterns, expandedExcludedCaseKeys);
+  const remoteByPath = indexEntries(remoteEntries, ignorePatterns, expandedExcludedCaseKeys);
+  const stateEntries = new Map(
+    Object.entries(state.entries || {}).flatMap(([path2, entry]) => {
+      const normalizedPath = normalizeSyncPath(path2);
+      if (!normalizedPath || !isSafeSyncPath(path2) || isSyncPathIgnored(normalizedPath, ignorePatterns) || expandedExcludedCaseKeys.has(caseFoldSyncPath(normalizedPath))) {
+        return [];
+      }
+      return [[normalizedPath, entry]];
+    })
+  );
+  const paths = /* @__PURE__ */ new Set([
+    ...localByPath.keys(),
+    ...remoteByPath.keys(),
+    ...stateEntries.keys()
+  ]);
+  const folderMoveActions = collectFolderMoveActions(localByPath, remoteByPath, stateEntries);
+  const folderMovedPaths = collectMovedStatePaths(folderMoveActions, stateEntries);
+  const fileMoveActions = collectFileMoveActions(localByPath, remoteByPath, stateEntries, folderMovedPaths);
+  const moveActions = [
+    ...folderMoveActions,
+    ...fileMoveActions
+  ];
+  const movedPaths = collectMovedStatePaths(moveActions, stateEntries);
+  const actions = [
+    ...collectUnsupportedLocalActions(localEntries, ignorePatterns),
+    ...collectUnsupportedRemoteActions(remoteEntries, ignorePatterns),
+    ...localCaseCollisions.actions,
+    ...remoteCaseCollisions.actions,
+    ...crossCaseCollisions.actions,
+    ...moveActions
+  ];
+  for (const path2 of paths) {
+    if (isSyncPathIgnored(path2, ignorePatterns) || movedPaths.has(path2)) {
+      continue;
+    }
+    const localEntry = localByPath.get(path2);
+    const remoteEntry = remoteByPath.get(path2);
+    const stateEntry = stateEntries.get(path2);
+    let action = null;
+    if (localEntry && remoteEntry) {
+      action = planBothPresent(path2, localEntry, remoteEntry, stateEntry);
+    } else if (localEntry) {
+      action = planLocalOnly(path2, localEntry, stateEntry);
+    } else if (remoteEntry) {
+      action = planRemoteOnly(path2, remoteEntry, stateEntry);
+    }
+    if (action) {
+      actions.push(action);
+    }
+  }
+  return compactRecursiveDeleteActions(convertCreatedDescendantsUnderDeletedFolders(actions)).sort((a, b) => {
+    const priority = ACTION_PRIORITY[a.type] - ACTION_PRIORITY[b.type];
+    return priority === 0 ? a.path.localeCompare(b.path) : priority;
+  });
+}
+
+// ../desktop/src/api-client.mjs
+import fs from "node:fs/promises";
+import path from "node:path";
+var REMOTE_TREE_PAGE_SIZE = 500;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RESPONSE_BYTES = 1 * 1024 * 1024;
+var DEFAULT_MAX_DOWNLOAD_BYTES = 64 * 1024 * 1024;
+var ZergBoxApiError = class extends Error {
+  constructor(message, { status, body } = {}) {
+    super(message);
+    this.name = "ZergBoxApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var ZergBoxSyncConflictError = class extends ZergBoxApiError {
+  constructor(message, {
+    status,
+    body,
+    resourceType,
+    resourceId,
+    expectedRevision,
+    resourcePath,
+    expectedAbsent
+  } = {}) {
+    super(message, { status, body });
+    this.name = "ZergBoxSyncConflictError";
+    this.code = "SYNC_CONFLICT";
+    this.recoverable = true;
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+    this.expectedRevision = expectedRevision;
+    this.resourcePath = resourcePath;
+    this.expectedAbsent = expectedAbsent;
+  }
+};
+function normalizeBaseUrl(baseUrl) {
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    throw new Error("baseUrl must be an exact HTTP(S) origin");
+  }
+  if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+    throw new Error("baseUrl must be an exact HTTP(S) origin");
+  }
+  return parsed.origin;
+}
+function resolveApiUrl(baseUrl, apiPath) {
+  if (typeof apiPath !== "string" || !/^\/api(?:\/|\?|$)/.test(apiPath)) {
+    throw new Error("apiPath must be an absolute same-origin /api path");
+  }
+  const resolvedUrl = new URL(apiPath, `${baseUrl}/`);
+  if (resolvedUrl.origin !== baseUrl || resolvedUrl.username || resolvedUrl.password || resolvedUrl.hash || !/^\/api(?:\/|$)/.test(resolvedUrl.pathname)) {
+    throw new Error("apiPath must be an absolute same-origin /api path");
+  }
+  return resolvedUrl;
+}
+function remoteFileFingerprint(file) {
+  if (typeof file.content_sha256 === "string" && /^[0-9a-f]{64}$/.test(file.content_sha256)) {
+    return file.content_sha256;
+  }
+  return [
+    file.current_version ?? "",
+    file.size_bytes ?? "",
+    file.updated_at ?? ""
+  ].join(":");
+}
+function expectedRevisionHeader(expectedRevision) {
+  if (!Number.isInteger(expectedRevision) || expectedRevision < 1) {
+    throw new Error("expectedRevision must be a positive integer");
+  }
+  return `"${expectedRevision}"`;
+}
+function normalizeBytes(bytes) {
+  if (Buffer.isBuffer(bytes)) {
+    return bytes;
+  }
+  if (bytes instanceof Uint8Array) {
+    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  throw new Error("bytes must be a Buffer or Uint8Array");
+}
+function joinRemotePath(parentPath, name) {
+  return normalizeSyncPath(parentPath ? `${parentPath}/${name}` : name);
+}
+function clampPageSize(pageSize) {
+  const parsed = Number(pageSize || REMOTE_TREE_PAGE_SIZE);
+  if (!Number.isFinite(parsed)) {
+    return REMOTE_TREE_PAGE_SIZE;
+  }
+  return Math.min(Math.max(Math.trunc(parsed), 1), REMOTE_TREE_PAGE_SIZE);
+}
+function appendQuery(apiPath, params) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null && value !== "") {
+      searchParams.set(key, String(value));
+    }
+  }
+  const query = searchParams.toString();
+  return query ? `${apiPath}?${query}` : apiPath;
+}
+function normalizeRequestTimeoutMs(value) {
+  const timeoutMs = Number(value ?? DEFAULT_REQUEST_TIMEOUT_MS);
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return DEFAULT_REQUEST_TIMEOUT_MS;
+  }
+  return Math.trunc(timeoutMs);
+}
+function normalizeByteLimit(value, fallback, name) {
+  const limit = Number(value ?? fallback);
+  if (!Number.isSafeInteger(limit) || limit < 1) {
+    throw new Error(`${name} must be a positive safe integer`);
+  }
+  return limit;
+}
+async function readBoundedResponse(response, maxBytes, label) {
+  const declaredLength = response.headers.get("content-length");
+  if (/^(0|[1-9][0-9]*)$/.test(declaredLength || "")) {
+    const parsedLength = Number(declaredLength);
+    if (!Number.isSafeInteger(parsedLength) || parsedLength > maxBytes) {
+      await response.body?.cancel(`${label} exceeded ${maxBytes} bytes`);
+      throw new ZergBoxApiError(`${label} exceeded ${maxBytes} bytes`, {
+        status: response.status
+      });
+    }
+  }
+  if (!response.body) {
+    return Buffer.alloc(0);
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      const chunk = Buffer.from(value);
+      totalBytes += chunk.length;
+      if (totalBytes > maxBytes) {
+        await reader.cancel(`${label} exceeded ${maxBytes} bytes`);
+        throw new ZergBoxApiError(`${label} exceeded ${maxBytes} bytes`, {
+          status: response.status
+        });
+      }
+      chunks.push(chunk);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, totalBytes);
+}
+function decodeResponseText(bytes) {
+  return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+}
+var ZergBoxDesktopClient = class {
+  constructor({
+    baseUrl,
+    token,
+    requestTimeoutMs,
+    maxResponseBytes,
+    maxDownloadBytes
+  }) {
+    if (!baseUrl) {
+      throw new Error("baseUrl is required");
+    }
+    if (!token) {
+      throw new Error("token is required");
+    }
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+    this.token = token;
+    this.requestTimeoutMs = normalizeRequestTimeoutMs(requestTimeoutMs);
+    this.maxResponseBytes = normalizeByteLimit(
+      maxResponseBytes,
+      DEFAULT_MAX_RESPONSE_BYTES,
+      "maxResponseBytes"
+    );
+    this.maxDownloadBytes = normalizeByteLimit(
+      maxDownloadBytes,
+      DEFAULT_MAX_DOWNLOAD_BYTES,
+      "maxDownloadBytes"
+    );
+  }
+  async request(apiPath, options = {}) {
+    const requestUrl = resolveApiUrl(this.baseUrl, apiPath);
+    const headers = new Headers(options.headers || {});
+    headers.set("Authorization", `Bearer ${this.token}`);
+    let body = options.body;
+    if (body && !(body instanceof FormData) && !Buffer.isBuffer(body)) {
+      headers.set("Content-Type", "application/json");
+      body = JSON.stringify(body);
+    }
+    const timeoutMs = normalizeRequestTimeoutMs(options.timeoutMs ?? this.requestTimeoutMs);
+    const abortController = new AbortController();
+    const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+    try {
+      const response = await fetch(requestUrl, {
+        method: options.method || "GET",
+        headers,
+        body,
+        redirect: "error",
+        signal: abortController.signal
+      });
+      if (!response.ok) {
+        const errorBytes = await readBoundedResponse(
+          response,
+          this.maxResponseBytes,
+          "ZergBox API error response"
+        );
+        const text2 = decodeResponseText(errorBytes);
+        if ([409, 412].includes(response.status) && options.syncConflict) {
+          throw new ZergBoxSyncConflictError(
+            `ZergBox sync conflict: ${response.status} ${response.statusText}`,
+            {
+              status: response.status,
+              body: text2,
+              ...options.syncConflict
+            }
+          );
+        }
+        throw new ZergBoxApiError(`ZergBox API request failed: ${response.status} ${response.statusText}`, {
+          status: response.status,
+          body: text2
+        });
+      }
+      if (response.status === 204) {
+        return null;
+      }
+      if (options.binary) {
+        return await readBoundedResponse(
+          response,
+          normalizeByteLimit(
+            options.maxResponseBytes,
+            this.maxDownloadBytes,
+            "maxDownloadBytes"
+          ),
+          "ZergBox download"
+        );
+      }
+      const responseBytes = await readBoundedResponse(
+        response,
+        this.maxResponseBytes,
+        "ZergBox API response"
+      );
+      const text = decodeResponseText(responseBytes);
+      const contentType = response.headers.get("content-type") || "";
+      return contentType.includes("application/json") ? JSON.parse(text) : text;
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        throw new ZergBoxApiError(`ZergBox API request timed out after ${timeoutMs}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async listOrganizations() {
+    const data = await this.request("/api/orgs");
+    return data.organizations || [];
+  }
+  async getRootFolder(orgId, options = {}) {
+    return this.request(appendQuery("/api/folders/root", {
+      orgId,
+      limit: options.limit,
+      offset: options.offset
+    }));
+  }
+  async getFolder(folderId, options = {}) {
+    return this.request(appendQuery(`/api/folders/${encodeURIComponent(folderId)}`, {
+      limit: options.limit,
+      offset: options.offset
+    }));
+  }
+  async getChanges({ rootFolderId, cursor = 0, limit = 100 }) {
+    return this.request(appendQuery(
+      `/api/folders/${encodeURIComponent(rootFolderId)}/changes`,
+      { cursor, limit }
+    ));
+  }
+  async listChanges(rootFolderId, options = {}) {
+    return this.getChanges({ rootFolderId, ...options });
+  }
+  async uploadBytes({
+    orgId,
+    folderId,
+    filename,
+    bytes,
+    mediaType = "application/octet-stream",
+    expectedAbsent = true
+  }) {
+    if (expectedAbsent !== true) {
+      throw new Error("uploadBytes only supports create-if-absent; use updateFileBytes with expectedRevision");
+    }
+    const formData = new FormData();
+    formData.append("orgId", orgId);
+    formData.append("folderId", folderId);
+    formData.append("replaceExisting", expectedAbsent ? "false" : "true");
+    formData.append("file", new Blob([normalizeBytes(bytes)], { type: mediaType }), filename);
+    return this.request("/api/files/upload", {
+      method: "POST",
+      headers: { "If-None-Match": "*" },
+      syncConflict: {
+        resourceType: "file",
+        resourceId: null,
+        resourcePath: `${folderId}/${filename}`,
+        expectedAbsent: true
+      },
+      body: formData
+    });
+  }
+  async updateFileBytes({
+    fileId,
+    filename = "content.bin",
+    bytes,
+    mediaType = "application/octet-stream",
+    expectedRevision
+  }) {
+    const formData = new FormData();
+    formData.append("file", new Blob([normalizeBytes(bytes)], { type: mediaType }), filename);
+    return this.request(`/api/files/${encodeURIComponent(fileId)}/content`, {
+      method: "PUT",
+      headers: { "If-Match": expectedRevisionHeader(expectedRevision) },
+      syncConflict: { resourceType: "file", resourceId: fileId, expectedRevision },
+      body: formData
+    });
+  }
+  async createFolder({
+    orgId,
+    parentFolderId,
+    name,
+    expectedAbsent,
+    createIfAbsent = expectedAbsent ?? true
+  }) {
+    if (!createIfAbsent) {
+      throw new Error("createFolder only supports create-if-absent");
+    }
+    return this.request("/api/folders", {
+      method: "POST",
+      headers: { "If-None-Match": "*" },
+      syncConflict: {
+        resourceType: "folder",
+        resourceId: null,
+        resourcePath: `${parentFolderId}/${name}`,
+        expectedAbsent: true
+      },
+      body: { orgId, parentFolderId, name }
+    });
+  }
+  async updateFolder({ folderId, name, parentFolderId, expectedRevision }) {
+    return this.request(`/api/folders/${encodeURIComponent(folderId)}`, {
+      method: "PATCH",
+      headers: { "If-Match": expectedRevisionHeader(expectedRevision) },
+      syncConflict: { resourceType: "folder", resourceId: folderId, expectedRevision },
+      body: {
+        name,
+        parentFolderId
+      }
+    });
+  }
+  async uploadFile({ orgId, folderId, filePath, filename, replaceExisting = true }) {
+    const data = await fs.readFile(filePath);
+    const resolvedFilename = filename || path.basename(filePath);
+    if (!replaceExisting) {
+      return this.uploadBytes({
+        orgId,
+        folderId,
+        filename: resolvedFilename,
+        bytes: data,
+        expectedAbsent: true
+      });
+    }
+    const formData = new FormData();
+    formData.append("orgId", orgId);
+    formData.append("folderId", folderId);
+    formData.append("replaceExisting", "true");
+    formData.append("file", new Blob([data]), resolvedFilename);
+    return this.request("/api/files/upload", { method: "POST", body: formData });
+  }
+  async updateFileContent({ fileId, filePath, expectedRevision }) {
+    const data = await fs.readFile(filePath);
+    return this.updateFileBytes({
+      fileId,
+      filename: path.basename(filePath),
+      bytes: data,
+      expectedRevision
+    });
+  }
+  async updateFile({ fileId, name, folderId, expectedRevision }) {
+    return this.request(`/api/files/${encodeURIComponent(fileId)}`, {
+      method: "PATCH",
+      headers: { "If-Match": expectedRevisionHeader(expectedRevision) },
+      syncConflict: { resourceType: "file", resourceId: fileId, expectedRevision },
+      body: {
+        name,
+        folderId
+      }
+    });
+  }
+  async downloadFile(fileId, { maxBytes } = {}) {
+    return this.request(`/api/files/${encodeURIComponent(fileId)}/download`, {
+      binary: true,
+      maxResponseBytes: maxBytes
+    });
+  }
+  async deleteRemoteFile(fileId, { expectedRevision } = {}) {
+    return this.request(`/api/files/${encodeURIComponent(fileId)}`, {
+      method: "DELETE",
+      headers: { "If-Match": expectedRevisionHeader(expectedRevision) },
+      syncConflict: { resourceType: "file", resourceId: fileId, expectedRevision }
+    });
+  }
+  async deleteRemoteFolder(folderId, { expectedRevision } = {}) {
+    return this.request(`/api/folders/${encodeURIComponent(folderId)}`, {
+      method: "DELETE",
+      headers: { "If-Match": expectedRevisionHeader(expectedRevision) },
+      syncConflict: { resourceType: "folder", resourceId: folderId, expectedRevision }
+    });
+  }
+};
+async function getAllFolderPages(loadPage, pageSize) {
+  const pages = [];
+  let offset = 0;
+  while (true) {
+    const page = await loadPage({ limit: pageSize, offset });
+    pages.push(page);
+    const folderCount = page.folders?.length || 0;
+    const fileCount = page.files?.length || 0;
+    if (folderCount < pageSize && fileCount < pageSize) {
+      break;
+    }
+    offset += pageSize;
+  }
+  return {
+    folder: pages[0].folder,
+    folders: pages.flatMap((page) => page.folders || []),
+    files: pages.flatMap((page) => page.files || [])
+  };
+}
+async function walkRemoteFolder(client, folderData, parentPath, entries, pageSize) {
+  for (const folder of folderData.folders || []) {
+    const folderPath = joinRemotePath(parentPath, folder.name);
+    entries.push({
+      path: folderPath,
+      type: "directory",
+      id: folder.id,
+      revision: Number(folder.revision || 1),
+      updatedAt: folder.updated_at
+    });
+    const childData = await getAllFolderPages((options) => client.getFolder(folder.id, options), pageSize);
+    await walkRemoteFolder(client, childData, folderPath, entries, pageSize);
+  }
+  for (const file of folderData.files || []) {
+    entries.push({
+      path: joinRemotePath(parentPath, file.name),
+      type: "file",
+      id: file.id,
+      contentHash: remoteFileFingerprint(file),
+      revision: Number(file.revision || 1),
+      sizeBytes: Number(file.size_bytes || 0),
+      updatedAt: file.updated_at
+    });
+  }
+}
+async function fetchRemoteTree(client, {
+  orgId,
+  rootFolderId,
+  pageSize = REMOTE_TREE_PAGE_SIZE
+}) {
+  const normalizedPageSize = clampPageSize(pageSize);
+  const loadRootPage = rootFolderId ? (options) => client.getFolder(rootFolderId, options) : (options) => client.getRootFolder(orgId, options);
+  const rootData = await getAllFolderPages(loadRootPage, normalizedPageSize);
+  if (!rootData.folder?.id) {
+    throw new ZergBoxApiError("ZergBox remote root response did not include a folder");
+  }
+  if (rootFolderId && rootData.folder.id !== rootFolderId) {
+    throw new ZergBoxApiError(
+      `ZergBox remote root mismatch: requested ${rootFolderId}, received ${rootData.folder.id}`
+    );
+  }
+  const entries = [];
+  await walkRemoteFolder(client, rootData, "", entries, normalizedPageSize);
+  return {
+    rootFolder: rootData.folder,
+    entries: entries.sort((a, b) => a.path.localeCompare(b.path))
+  };
+}
+
+// src/contracts.mjs
+var SYNC_NODE_TYPES = Object.freeze(["directory", "file"]);
+var SYNC_CHANGE_TYPES = Object.freeze([
+  "create_remote_folder",
+  "move_remote_folder",
+  "upload_file",
+  "move_remote_file",
+  "create_local_folder",
+  "move_local_folder",
+  "download_file",
+  "move_local_file",
+  "conflict",
+  "delete_remote",
+  "delete_remote_folder",
+  "delete_local",
+  "delete_local_folder"
+]);
+var MERGE_CANDIDATE_STATES = Object.freeze([
+  "pending",
+  "resolved",
+  "dismissed"
+]);
+function isSyncNode(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.id === "string" && typeof value.path === "string" && SYNC_NODE_TYPES.includes(value.type)
+  );
+}
+function isSyncChange(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.path === "string" && SYNC_CHANGE_TYPES.includes(value.type)
+  );
+}
+function isMergeCandidate(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.id === "string" && typeof value.path === "string" && MERGE_CANDIDATE_STATES.includes(value.state) && isSyncNode(value.local) && isSyncNode(value.remote)
+  );
+}
+
+export {
+  DEFAULT_IGNORE_PATTERNS,
+  normalizeSyncPath,
+  isSafeSyncPath,
+  isSyncPathIgnored,
+  planSync,
+  ZergBoxApiError,
+  ZergBoxSyncConflictError,
+  remoteFileFingerprint,
+  ZergBoxDesktopClient,
+  fetchRemoteTree,
+  SYNC_NODE_TYPES,
+  SYNC_CHANGE_TYPES,
+  MERGE_CANDIDATE_STATES,
+  isSyncNode,
+  isSyncChange,
+  isMergeCandidate
+};