@doubling/compound-sync 1.10.5 → 1.12.0

package/org-sync.js

@@ -15,7 +15,7 @@
 import chokidar from 'chokidar';
 import fs from 'fs';
 import path from 'path';
-import { collection, query, where, onSnapshot } from 'firebase/firestore';
+import { collection, query, where, onSnapshot, getDocs } from 'firebase/firestore';
 import {
   pushFileToCloud,
   deleteFileFromCloud,
@@ -37,6 +37,11 @@ import {
 } from './paths.js';
 import { TeamRegistry } from './team-registry.js';
 import { loadSyncState, saveSyncState } from './sync-state.js';
+import { FirestoreUpdateStore } from './yjs-firestore-update-store.js';
+import { YjsFileBinding } from './yjs-file-binding.js';
+import {
+  loadBindingState, saveBindingState, deleteBindingState,
+} from './yjs-binding-state.js';
 
 const DEFAULT_MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
 
@@ -106,6 +111,122 @@ export async function startOrgSync({
   function setBaseline(key, hash) { lastSyncedHash.set(key, hash); persistBaseline(); }
   function deleteBaseline(key) { lastSyncedHash.delete(key); persistBaseline(); }
   const suppressLocal = new Set();
+
+  // Per-file Yjs bindings, created on first sight of a text file
+  // (DOU-178 PR 3). The binding owns the live Y.Doc that mirrors
+  // orgs/.../yupdates and the debounced disk flush. We keep two
+  // indexes: by fileId (so handleFirestoreChange can dispose on
+  // 'removed' and re-use across events) and by local path (so the
+  // chokidar handler can route disk edits into the binding without
+  // re-resolving the fileId).
+  const bindings = new Map();
+  const bindingsByPath = new Map();
+
+  // DOU-205: per-fileId record of the most recently observed Firestore
+  // metadata (local path + tracking key). Used to detect renames /
+  // moves on subsequent 'modified' snapshot events: when the file
+  // doc's path changes server-side (via the web rename UI), the local
+  // path computed from the new data also changes, and this map lets
+  // the handler relocate the local file in place (fs.renameSync,
+  // which preserves Obsidian's inode-level tracking) rather than
+  // leaving the old file orphaned at its previous location.
+  const knownPaths = new Map();
+
+  // Track which fileIds already have a binding (or one being set
+  // up) so we never double-create. `stoppedRef` is read by the
+  // background retry loops so they can abandon work after sync.stop.
+  // `pendingPromises` lets stop() await any in-flight setup before
+  // returning so the next test's clearFirestore does not race
+  // dangling onSnapshot streams.
+  const pendingBindings = new Set();
+  const pendingPromises = new Set();
+  const stoppedRef = { value: false };
+
+  // Fire-and-forget binding setup. Returns nothing because the
+  // common shape "ensureBinding then read its ytext" runs straight
+  // into a race: the daemon's onSnapshot fires on Alice's own
+  // optimistic write before the file doc is server-committed, and
+  // the Firestore rules engine evaluates the yupdates/yjs nested
+  // rule via a server-side get() against the parent files/{id}
+  // doc. That get() sees no doc and returns null, so binding.start
+  // fails with permission-denied; the right behavior is to retry
+  // until the commit propagates, not to block handleFirestoreChange
+  // for seconds. Callers fall back to the blob path while the
+  // binding is still being set up; once it lands in
+  // bindings/bindingsByPath, subsequent events take the Yjs path.
+  function ensureBinding(fileId, localFilePath) {
+    if (bindings.has(fileId) || pendingBindings.has(fileId)) return;
+    pendingBindings.add(fileId);
+    const onDiskWrite = (text) => {
+      suppressLocal.add(localFilePath);
+      ensureDir(localFilePath);
+      fs.writeFileSync(localFilePath, text, 'utf-8');
+      setTimeout(() => suppressLocal.delete(localFilePath), 1000);
+    };
+    // DOU-209: persist the Y.Doc binary state after every stable
+    // change so the next daemon restart has the right baseline to
+    // merge offline disk edits without losing offline web edits.
+    const onDocStateChange = (encoded) => saveBindingState(LOCAL_PATH, fileId, encoded);
+    // DOU-209: feed the binding's startup-merge with the daemon's
+    // last view (initialDocState) and the current disk content. If
+    // they diverge, the binding applies the diff as Yjs ops so disk-
+    // side offline edits survive the cloud-side replay.
+    const initialDocState = loadBindingState(LOCAL_PATH, fileId);
+    let currentDiskText = null;
+    try {
+      if (fs.existsSync(localFilePath)) {
+        currentDiskText = fs.readFileSync(localFilePath, 'utf-8');
+      }
+    } catch (err) {
+      console.error(`  [${orgId}] could not read ${localFilePath} for binding setup: ${err && err.message}`);
+    }
+    const setupPromise = (async () => {
+      // Retry binding.start on permission-denied. See note above
+      // about the optimistic-write race with the nested-rule get().
+      // YjsProvider rejects double-start, so each retry needs a
+      // fresh binding (and a fresh provider underneath it).
+      for (let attempt = 0; attempt < 8; attempt++) {
+        if (stoppedRef.value) return;
+        const store = new FirestoreUpdateStore(db, orgId, fileId);
+        const binding = new YjsFileBinding(store, {
+          onDiskWrite, onDocStateChange, initialDocState, currentDiskText,
+        });
+        try {
+          await binding.start();
+          if (stoppedRef.value) {
+            await binding.stop().catch(() => {});
+            return;
+          }
+          bindings.set(fileId, binding);
+          bindingsByPath.set(localFilePath, binding);
+          return;
+        } catch (err) {
+          if (stoppedRef.value) return;
+          if (err?.code !== 'permission-denied' || attempt === 7) {
+            console.error(`  [${orgId}] Yjs binding setup failed for ${fileId}: ${err && err.message}`);
+            return;
+          }
+          await new Promise((r) => setTimeout(r, 150 * (attempt + 1)));
+        }
+      }
+    })().finally(() => {
+      pendingBindings.delete(fileId);
+      pendingPromises.delete(setupPromise);
+    });
+    pendingPromises.add(setupPromise);
+  }
+
+  async function disposeBinding(fileId, localFilePath) {
+    const binding = bindings.get(fileId);
+    if (!binding) return;
+    bindings.delete(fileId);
+    if (localFilePath) bindingsByPath.delete(localFilePath);
+    await binding.stop();
+    // DOU-209: drop the per-file Y.Doc state so deleted files don't
+    // accumulate stale binding-state blobs under .compound-yjs-binding/.
+    deleteBindingState(LOCAL_PATH, fileId);
+  }
+
   // Per-team Firestore-listener unsubscribe handles, keyed by teamId.
   const teamUnsubscribers = new Map();
   // Hoisted forward-decl: setupTeam closes over handleFirestoreChange,
@@ -188,6 +309,48 @@ export async function startOrgSync({
     const trackingKey = `${data.scope || 'team'}:${docPath}`;
     const isFolder = data.type === 'folder';
 
+    // DOU-205: rename / move detection. On a 'modified' snapshot for
+    // a fileId we've seen before, if the computed local path differs
+    // from what we last recorded, the server's path field has
+    // changed. Move the local file in place (fs.renameSync preserves
+    // Obsidian's inode tracking so notes don't lose their metadata,
+    // backlinks, or recent-files entries) and migrate the tracking
+    // maps from the old key to the new. We do this before the
+    // freshness check below because the rename happens irrespective
+    // of whether the content changed in the same update.
+    const fileId = change.doc.id;
+    const prevKnown = knownPaths.get(fileId);
+    if (change.type === 'modified' && prevKnown && prevKnown.localPath !== localFilePath) {
+      suppressLocal.add(prevKnown.localPath);
+      suppressLocal.add(localFilePath);
+      try {
+        if (fs.existsSync(prevKnown.localPath)) {
+          ensureDir(localFilePath);
+          fs.renameSync(prevKnown.localPath, localFilePath);
+          console.log(`  [${orgId}] [firestore → local] RENAME ${prevKnown.localPath} -> ${localFilePath}`);
+        }
+      } catch (err) {
+        console.error(`  [${orgId}] [firestore → local] RENAME failed: ${err && err.message}`);
+      }
+      if (lastKnownUpdate.has(prevKnown.trackingKey)) {
+        lastKnownUpdate.set(trackingKey, lastKnownUpdate.get(prevKnown.trackingKey));
+        lastKnownUpdate.delete(prevKnown.trackingKey);
+      }
+      if (lastSyncedHash.has(prevKnown.trackingKey)) {
+        setBaseline(trackingKey, lastSyncedHash.get(prevKnown.trackingKey));
+        deleteBaseline(prevKnown.trackingKey);
+      }
+      const binding = bindings.get(fileId);
+      if (binding && bindingsByPath.get(prevKnown.localPath) === binding) {
+        bindingsByPath.delete(prevKnown.localPath);
+        bindingsByPath.set(localFilePath, binding);
+      }
+      setTimeout(() => {
+        suppressLocal.delete(prevKnown.localPath);
+        suppressLocal.delete(localFilePath);
+      }, 1000);
+    }
+
     if (change.type === 'removed') {
       if (isFolder) {
         // Best-effort directory removal. The daemon's own file-delete
@@ -213,9 +376,27 @@ export async function startOrgSync({
       }
       lastKnownUpdate.delete(trackingKey);
       deleteBaseline(trackingKey);
+      knownPaths.delete(fileId);
+      await disposeBinding(change.doc.id, localFilePath);
       return;
     }
 
+    // Record (or refresh) the per-fileId path so the next 'modified'
+    // event can detect a rename / move by comparing against this.
+    knownPaths.set(fileId, { localPath: localFilePath, trackingKey });
+
+    // Kick off Yjs binding setup for text files. Fire-and-forget so
+    // a slow start (retrying past the rules-engine race on a fresh
+    // doc) does not stall the legacy blob pull. Once the binding is
+    // registered, future events take the Yjs path; until then the
+    // blob path still keeps disk in sync.
+    if (!isFolder) {
+      const ext = extFromPath(docPath);
+      const extDerivedMime = mimeTypeFromExt(ext);
+      const isText = isTextMimeType(data.mimeType) || isTextMimeType(extDerivedMime);
+      if (isText) ensureBinding(change.doc.id, localFilePath);
+    }
+
     const remoteUpdated = data.updatedAt || data.createdAt || '';
     const lastKnown = lastKnownUpdate.get(trackingKey);
     if (lastKnown && lastKnown >= remoteUpdated) return;
@@ -282,6 +463,23 @@ export async function startOrgSync({
     // markers) can apply.
     const extDerivedMime = mimeTypeFromExt(ext);
     const isText = isTextMimeType(data.mimeType) || isTextMimeType(extDerivedMime);
+
+    // Yjs path (DOU-178 PR 3): if a binding for this file is already
+    // up and carries non-empty ytext, the debounced flush owns the
+    // disk write and the legacy blob pull is skipped. Bindings that
+    // are still being set up, or that loaded empty ytext (pre-Yjs
+    // files), fall through to the blob path; PR 4 retires the blob
+    // path entirely.
+    if (isText) {
+      const binding = bindings.get(change.doc.id);
+      if (binding && binding.ytext.length > 0) {
+        lastKnownUpdate.set(trackingKey, remoteUpdated);
+        setBaseline(trackingKey, data.contentHash);
+        setTimeout(() => suppressLocal.delete(localFilePath), 1000);
+        return;
+      }
+    }
+
     // Storage rules require the Firestore doc to exist before they
     // authorize a blob upload, so writers must create the doc first
     // and upload second. That leaves a window where the metadata is
@@ -402,6 +600,34 @@ export async function startOrgSync({
     }
   }
 
+  // DOU-217 helper: does a doc with this path + matching contentHash
+  // exist in Firestore right now? Used to verify a baseline entry
+  // before trusting it (so a stale baseline can't silently suppress
+  // re-upload of a file whose Firestore doc was deleted out-of-band).
+  async function firestoreDocExists({ scope, teamId, docPath, contentHash }) {
+    let q;
+    if (scope === 'private') {
+      q = query(filesRef,
+        where('scope', '==', 'private'),
+        where('ownerId', '==', userId),
+        where('path', '==', docPath));
+    } else if (scope === 'team' && teamId) {
+      q = query(filesRef,
+        where('scope', '==', 'team'),
+        where('teamId', '==', teamId),
+        where('path', '==', docPath));
+    } else {
+      return false;
+    }
+    const snap = await getDocs(q);
+    if (snap.empty) return false;
+    // Also require the doc's contentHash to match the baseline. A doc
+    // with the same path but a different hash means a web edit
+    // happened that the daemon didn't observe; treat as "missing" so
+    // the push side proceeds and the pull side can reconcile.
+    return snap.docs[0].data().contentHash === contentHash;
+  }
+
   async function pushToFirestore(filePath, data, mimeType, localModifiedAt) {
     const { scope, teamId, docPath } = scopeFromLocalPath(filePath, LOCAL_PATH, teamIdsByName);
     const trackingKey = `${scope}:${docPath}`;
@@ -411,8 +637,22 @@ export async function startOrgSync({
     // re-saving or touching a file (or the watcher re-emitting it on
     // startup) must not push stale bytes over a newer server edit. Only
     // a genuine content change proceeds.
+    //
+    // DOU-217: trust the baseline ONLY after verifying the Firestore
+    // doc actually exists. The baseline is persisted across daemon
+    // restarts, so a doc deleted out-of-band (web delete the daemon
+    // missed while offline, manual cleanup, etc.) leaves a permanently
+    // stale entry that would silently suppress re-upload forever.
+    // Verifying via a single indexed read per touch is cheap; if the
+    // doc is gone, clear the baseline and fall through to push.
     const contentHash = computeContentHash(data);
-    if (lastSyncedHash.get(trackingKey) === contentHash) return;
+    if (lastSyncedHash.get(trackingKey) === contentHash) {
+      if (await firestoreDocExists({ scope, teamId, docPath, contentHash })) {
+        return;
+      }
+      console.log(`  [${orgId}] [reconcile] dropping stale baseline for ${docPath} (Firestore doc missing); re-pushing`);
+      deleteBaseline(trackingKey);
+    }
 
     const now = new Date().toISOString();
 
@@ -425,12 +665,6 @@ export async function startOrgSync({
     // duplicate doc). Pre-setting it suppresses the echo.
     lastKnownUpdate.set(trackingKey, now);
 
-    // Baseline = what we last saw as the remote contentHash for this
-    // path. pushFileToCloud uses it as a compare-and-swap precondition
-    // (DOU-167): if the remote has moved past this baseline, refuse
-    // the push and surface the conflict to the caller.
-    const baseline = lastSyncedHash.get(trackingKey);
-
     const result = await pushFileToCloud({
       filesRef,
       storage,
@@ -443,7 +677,6 @@ export async function startOrgSync({
       mimeType,
       now,
       localModifiedAt,
-      expectedRemoteHash: baseline,
     });
 
     // Record the synced content baseline whenever local matches the
@@ -456,21 +689,6 @@ export async function startOrgSync({
       // its firestore -> local snapshot is allowed through to update the
       // local file.
       lastKnownUpdate.delete(trackingKey);
-    } else if (result.action === 'conflict') {
-      // Another writer landed an edit in the gap between our last sync
-      // and this push. Preserve the user's would-be push as a sibling
-      // conflict copy, pull the new remote state into the live file,
-      // and advance the baseline so the next push (or further edits)
-      // can proceed against the new ground truth.
-      const conflictPath = writeConflictCopy(filePath, data);
-      await pullRemoteIntoLocal(result.remoteData, filePath);
-      setBaseline(trackingKey, result.remoteHash);
-      lastKnownUpdate.delete(trackingKey);
-      console.log(
-        `  [${orgId}] [local → firestore] CONFLICT ${docPath}: ` +
-        `remote changed; local saved to ${path.basename(conflictPath)}`,
-      );
-      return;
     }
 
     if (result.action === 'created') {
@@ -485,38 +703,6 @@ export async function startOrgSync({
     }
   }
 
-  /** Write the proposed (rejected) push to a sibling conflict file.
-   * Returns the new path. Suppresses chokidar so the conflict file's
-   * creation doesn't trigger its own push. */
-  function writeConflictCopy(filePath, data) {
-    const parsed = path.parse(filePath);
-    const ts = new Date().toISOString().replace(/[:.]/g, '-');
-    const conflictPath = path.join(parsed.dir, `${parsed.name}.conflict-${ts}${parsed.ext}`);
-    suppressLocal.add(conflictPath);
-    fs.writeFileSync(conflictPath, data);
-    setTimeout(() => suppressLocal.delete(conflictPath), 1000);
-    return conflictPath;
-  }
-
-  /** Pull the remote blob into the live local path after a conflict.
-   * Uses suppressLocal so chokidar doesn't re-emit the write. */
-  async function pullRemoteIntoLocal(remoteData, localFilePath) {
-    const ext = extFromPath(remoteData.path);
-    const extDerivedMime = mimeTypeFromExt(ext);
-    const isText = isTextMimeType(remoteData.mimeType) || isTextMimeType(extDerivedMime);
-    suppressLocal.add(localFilePath);
-    const blobReadArgs = { storage, orgId, fileId: remoteData.id, ext };
-    const retryOpts = { expectedHash: remoteData.contentHash };
-    if (isText) {
-      const content = await readBlobWithRetry(() => readBlobAsText(blobReadArgs), retryOpts);
-      fs.writeFileSync(localFilePath, content || '', 'utf-8');
-    } else {
-      const bytes = await readBlobWithRetry(() => readBlob(blobReadArgs), retryOpts);
-      fs.writeFileSync(localFilePath, bytes);
-    }
-    setTimeout(() => suppressLocal.delete(localFilePath), 1000);
-  }
-
   async function deleteFromFirestore(filePath) {
     const { scope, teamId, docPath } = scopeFromLocalPath(filePath, LOCAL_PATH, teamIdsByName);
     const trackingKey = `${scope}:${docPath}`;
@@ -584,6 +770,8 @@ export async function startOrgSync({
 
     const result = await deleteFolderFromCloud({
       filesRef,
+      storage,
+      orgId,
       scope,
       teamId,
       userId,
@@ -591,7 +779,10 @@ export async function startOrgSync({
     });
 
     if (result.action === 'deleted') {
-      console.log(`  [${orgId}] [local → firestore] RMFOLDER ${docPath} (${scope})`);
+      // childCount > 0 means cascade did real work; useful in logs
+      // when investigating future folder-delete reports.
+      const childSuffix = result.childCount > 0 ? ` (+${result.childCount} children)` : '';
+      console.log(`  [${orgId}] [local → firestore] RMFOLDER ${docPath} (${scope})${childSuffix}`);
     }
   }
 
@@ -623,8 +814,21 @@ export async function startOrgSync({
       ? fs.readFileSync(filePath, 'utf-8')
       : fs.readFileSync(filePath);
     const localModifiedAt = stat.mtime.toISOString();
+
+    // Yjs path (DOU-178 PR 3): route text edits into the binding so
+    // the disk delta is published as a yupdate (preserving concurrent
+    // web edits via fast-diff). The binding only exists once the
+    // Firestore listener has seen the file; for the very first
+    // local-only save the binding hasn't been created yet, and the
+    // blob path is still the only writer. Subsequent saves go through
+    // both paths until PR 4 retires the blob upload.
+    if (isTextMimeType(mimeType)) {
+      const binding = bindingsByPath.get(filePath);
+      if (binding) binding.applyDiskText(data);
+    }
+
     pushToFirestore(filePath, data, mimeType, localModifiedAt).catch(err =>
-      console.error(`  [${orgId}] Push error: ${err.message}`)
+      console.error(`  [${orgId}] Push error for ${rel}: ${err.message}`)
     );
   }
 
@@ -671,7 +875,8 @@ export async function startOrgSync({
     watcher.on('change', filePath => handleLocalChange(filePath));
     watcher.on('unlink', filePath => {
       if (suppressLocal.has(filePath)) return;
-      deleteFromFirestore(filePath).catch(err => console.error(`  [${orgId}] Delete error: ${err.message}`));
+      const rel = path.relative(LOCAL_PATH, filePath);
+      deleteFromFirestore(filePath).catch(err => console.error(`  [${orgId}] Delete error for ${rel}: ${err.message}`));
     });
     watcher.on('addDir', dirPath => handleLocalDirAdded(dirPath));
     watcher.on('unlinkDir', dirPath => handleLocalDirRemoved(dirPath));
@@ -697,6 +902,7 @@ export async function startOrgSync({
     // Tear down all listeners and the watcher. Returns the watcher's
     // close() promise so callers/tests can await full shutdown.
     stop() {
+      stoppedRef.value = true;
       for (const unsub of unsubscribers) {
         try { unsub(); } catch (e) { /* ignore */ }
       }
@@ -704,7 +910,15 @@ export async function startOrgSync({
         try { unsub(); } catch (e) { /* ignore */ }
       }
       teamUnsubscribers.clear();
-      return watcher ? watcher.close() : Promise.resolve();
+      const setupDrain = Promise.all([...pendingPromises]);
+      const bindingDrain = setupDrain.then(() => Promise.all(
+        [...bindings.values()].map((b) => b.stop().catch(() => {})),
+      )).then(() => {
+        bindings.clear();
+        bindingsByPath.clear();
+      });
+      const watcherClose = watcher ? watcher.close() : Promise.resolve();
+      return Promise.all([bindingDrain, watcherClose]).then(() => undefined);
     },
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doubling/compound-sync",
-  "version": "1.10.5",
+  "version": "1.12.0",
   "description": "Bidirectional sync between Compound and local markdown files",
   "type": "module",
   "bin": {
@@ -12,6 +12,7 @@
     "sync-state.js",
     "config.js",
     "paths.js",
+    "paths.d.ts",
     "files.js",
     "folder-chain.js",
     "storage-helpers.js",
@@ -19,21 +20,33 @@
     "auth-persistence.js",
     "pre-mint-app-check.js",
     "setup-auth-with-pre-mint.js",
+    "yjs-firestore-update-store.js",
+    "yjs-provider.js",
+    "yjs-file-binding.js",
+    "yjs-binding-state.js",
     "README.md"
   ],
   "scripts": {
-    "sync": "node sync.js",
-    "test:unit": "node --test config.test.js paths.test.js storage-helpers.test.js folder-chain.test.js team-registry.test.js auth-persistence.test.js pre-mint-app-check.test.js setup-auth-with-pre-mint.test.js sync-state.test.js",
-    "test:integration": "firebase emulators:exec --only firestore,storage 'node --test --test-concurrency=1 files.test.js org-sync.test.js two-user-sync.test.js'",
+    "sync": "node --import tsx ./sync.js",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepack": "npm run build",
+    "test:unit": "node --import tsx --test config.test.js paths.test.js storage-helpers.test.js folder-chain.test.js team-registry.test.js auth-persistence.test.js pre-mint-app-check.test.js setup-auth-with-pre-mint.test.js sync-state.test.js yjs-file-binding.test.js yjs-binding-state.test.js",
+    "test:integration": "firebase emulators:exec --only firestore,storage 'node --import tsx --test --test-concurrency=1 files.test.js org-sync.test.js two-user-sync.test.js'",
     "test": "npm run test:unit && npm run test:integration"
   },
   "dependencies": {
+    "chokidar": "^5.0.0",
+    "fast-diff": "^1.3.0",
     "firebase": "^12.14.0",
-    "chokidar": "^5.0.0"
+    "yjs": "^13.6.31"
   },
   "devDependencies": {
     "@firebase/rules-unit-testing": "^5.0.1",
-    "firebase-tools": "^15.20.0"
+    "@types/node": "^26.0.0",
+    "firebase-tools": "^15.20.0",
+    "tsx": "^4.22.4",
+    "typescript": "^5.9.3"
   },
   "publishConfig": {
     "access": "public"

package/paths.d.ts

@@ -0,0 +1,12 @@
+export declare const PRIVATE_FOLDER = "Private";
+export declare const SHARED_WITH_ME_FOLDER = "Shared with Me";
+export declare const SHARED_BY_ME_FOLDER = "Shared by Me";
+export type Scope = 'team' | 'private' | 'shared-with-me' | 'shared-by-me';
+export interface ScopedDocPath {
+    scope: Scope;
+    teamId?: string;
+    docPath: string;
+}
+export declare function teamFolderName(teamName: string): string;
+export declare function scopeFromLocalPath(filePath: string, localPath: string, teamIdsByName: Map<string, string>): ScopedDocPath;
+//# sourceMappingURL=paths.d.ts.map

package/paths.js

@@ -5,48 +5,43 @@
 // expected to be swapped if/when authorization moves to a Zanzibar-
 // style relationship model. Keep this module's interface narrow so the
 // swap stays localized.
-
 import path from 'node:path';
-
 export const PRIVATE_FOLDER = 'Private';
 export const SHARED_WITH_ME_FOLDER = 'Shared with Me';
 export const SHARED_BY_ME_FOLDER = 'Shared by Me';
 const TEAMSPACE_SUFFIX = ' Teamspace';
-
 export function teamFolderName(teamName) {
-  return teamName + TEAMSPACE_SUFFIX;
+    return teamName + TEAMSPACE_SUFFIX;
 }
-
 // Given an absolute file path within one of the daemon's local sync
 // roots, return { scope, teamId?, docPath }. The caller passes the
-// matching localPath root and the team-name → team-id map.
+// matching localPath root and the team-name -> team-id map.
 export function scopeFromLocalPath(filePath, localPath, teamIdsByName) {
-  const rel = path.relative(localPath, filePath);
-
-  if (rel.startsWith(PRIVATE_FOLDER + path.sep)) {
-    return {
-      scope: 'private',
-      docPath: rel.slice(PRIVATE_FOLDER.length + 1),
-    };
-  }
-  if (rel.startsWith(SHARED_WITH_ME_FOLDER + path.sep)) {
-    return {
-      scope: 'shared-with-me',
-      docPath: rel.slice(SHARED_WITH_ME_FOLDER.length + 1),
-    };
-  }
-  if (rel.startsWith(SHARED_BY_ME_FOLDER + path.sep)) {
-    return {
-      scope: 'shared-by-me',
-      docPath: rel.slice(SHARED_BY_ME_FOLDER.length + 1),
-    };
-  }
-
-  const parts = rel.split(path.sep);
-  const folderName = parts[0];
-  const teamName = folderName.endsWith(TEAMSPACE_SUFFIX)
-    ? folderName.slice(0, -TEAMSPACE_SUFFIX.length)
-    : folderName;
-  const teamId = teamIdsByName.get(teamName);
-  return { scope: 'team', teamId, docPath: parts.slice(1).join('/') };
+    const rel = path.relative(localPath, filePath);
+    if (rel.startsWith(PRIVATE_FOLDER + path.sep)) {
+        return {
+            scope: 'private',
+            docPath: rel.slice(PRIVATE_FOLDER.length + 1),
+        };
+    }
+    if (rel.startsWith(SHARED_WITH_ME_FOLDER + path.sep)) {
+        return {
+            scope: 'shared-with-me',
+            docPath: rel.slice(SHARED_WITH_ME_FOLDER.length + 1),
+        };
+    }
+    if (rel.startsWith(SHARED_BY_ME_FOLDER + path.sep)) {
+        return {
+            scope: 'shared-by-me',
+            docPath: rel.slice(SHARED_BY_ME_FOLDER.length + 1),
+        };
+    }
+    const parts = rel.split(path.sep);
+    const folderName = parts[0] ?? '';
+    const teamName = folderName.endsWith(TEAMSPACE_SUFFIX)
+        ? folderName.slice(0, -TEAMSPACE_SUFFIX.length)
+        : folderName;
+    const teamId = teamIdsByName.get(teamName);
+    return { scope: 'team', teamId, docPath: parts.slice(1).join('/') };
 }
+//# sourceMappingURL=paths.js.map

package/storage-helpers.js

@@ -81,6 +81,8 @@ const EXT_TO_MIME = {
   webp: 'image/webp',
   svg: 'image/svg+xml',
   bmp: 'image/bmp',
+  heic: 'image/heic',
+  heif: 'image/heif',
   mp3: 'audio/mpeg',
   wav: 'audio/wav',
   mp4: 'video/mp4',

package/sync.js

@@ -16,6 +16,43 @@
  *        node sync.js --help
  */
 
+// DOU-208: Node 22+ ships its own CA bundle and does not consult the
+// macOS system trust store. Without NODE_EXTRA_CA_CERTS pointing at
+// /etc/ssl/cert.pem, fetch() to securetoken.googleapis.com fails
+// with a bare `fetch failed`, which Firebase Auth then surfaces as
+// auth/network-request-failed. The web e2e harness's run-emulator.js
+// already does this for child processes; here we need it for our own
+// process. NODE_EXTRA_CA_CERTS is read at startup, so setting it on
+// process.env after init is a no-op — instead, re-exec ourselves
+// with the env var set when missing. The child inherits stdio +
+// argv; we exit with its status. No-op when already set (the user
+// or a wrapper explicitly chose a different bundle).
+import { spawnSync as __dou208_spawnSync } from 'node:child_process';
+import { existsSync as __dou208_existsSync } from 'node:fs';
+if (!process.env.NODE_EXTRA_CA_CERTS) {
+  const __dou208_candidates = process.platform === 'darwin'
+    ? ['/etc/ssl/cert.pem']
+    : process.platform === 'linux'
+      ? ['/etc/ssl/certs/ca-certificates.crt', '/etc/pki/tls/certs/ca-bundle.crt']
+      : [];
+  for (const __dou208_candidate of __dou208_candidates) {
+    if (__dou208_existsSync(__dou208_candidate)) {
+      const __dou208_result = __dou208_spawnSync(
+        process.execPath,
+        process.argv.slice(1),
+        {
+          stdio: 'inherit',
+          env: { ...process.env, NODE_EXTRA_CA_CERTS: __dou208_candidate },
+        },
+      );
+      process.exit(__dou208_result.status ?? 1);
+    }
+  }
+  // No candidate found (Windows, unusual Linux distro): fall through
+  // and let Node's bundled CA bundle handle TLS. The user can still
+  // set NODE_EXTRA_CA_CERTS manually for corporate cert chains.
+}
+
 import { initializeApp } from 'firebase/app';
 import { getAuth, initializeAuth, signInWithEmailAndPassword, signInWithCredential, GoogleAuthProvider } from 'firebase/auth';
 import {