@doubling/compound-sync 1.4.1 → 1.6.0

package/files.js

@@ -0,0 +1,438 @@
+// Cloud-side file persistence for the sync daemon and integration tests.
+//
+// Each function takes its dependencies (filesRef, storage, orgId, etc.)
+// as parameters so the logic is importable into a test harness that
+// provides emulator-backed Firebase handles. The sync daemon (sync.js)
+// is the production caller and supplies real Firebase handles.
+//
+// A "file" is a Firestore metadata document at
+//   orgs/{orgId}/files/{fileId}
+// plus a Storage blob at
+//   orgs/{orgId}/files/{fileId}/current.{ext}
+// where {ext} is derived from the file's path so Storage can serve the
+// correct Content-Type header automatically.
+//
+// Ordering on writes:
+//   1. Write/update the Firestore metadata document.
+//      (Storage rules require the metadata doc to exist before they
+//      authorize the blob upload.)
+//   2. Upload the blob to Cloud Storage.
+//   Storage failures are returned in the result, not thrown, so the
+//   caller can decide whether to surface as a soft warning and retry.
+//
+// Ordering on deletes:
+//   1. Delete the Storage blob (while metadata still exists so the
+//      Storage rule can authorize).
+//   2. Delete the Firestore metadata document.
+
+import {
+  doc, getDocs, setDoc, updateDoc, deleteDoc, query, where,
+} from 'firebase/firestore';
+import {
+  ref as storageRef, uploadBytes, deleteObject, getBytes,
+} from 'firebase/storage';
+
+import {
+  storagePathFor,
+  extFromPath,
+  contentByteSize,
+  computeContentHash,
+  toBytes,
+} from './storage-helpers.js';
+import { planFolderChain, splitPath } from './folder-chain.js';
+
+// Re-export pure helpers so callers (and existing tests) can import
+// either from here or directly from storage-helpers.js.
+export {
+  storagePathFor,
+  extFromPath,
+  contentByteSize,
+  computeContentHash,
+  isTextMimeType,
+  mimeTypeFromExt,
+} from './storage-helpers.js';
+
+// ---- Storage primitives ----
+
+export async function uploadBlob({ storage, orgId, fileId, ext, data, mimeType }) {
+  const blobPath = storagePathFor(orgId, fileId, ext);
+  const payload = toBytes(data);
+  await uploadBytes(storageRef(storage, blobPath), payload, {
+    contentType: mimeType || 'application/octet-stream',
+  });
+}
+
+export async function deleteBlob({ storage, orgId, fileId, ext }) {
+  const blobPath = storagePathFor(orgId, fileId, ext);
+  try {
+    await deleteObject(storageRef(storage, blobPath));
+  } catch (err) {
+    if (err && err.code === 'storage/object-not-found') {
+      return; // tolerate missing blob
+    }
+    throw err;
+  }
+}
+
+/**
+ * Read a blob from Cloud Storage as raw bytes. Throws on any failure
+ * (missing blob, permission error, network).
+ */
+export async function readBlob({ storage, orgId, fileId, ext }) {
+  const blobPath = storagePathFor(orgId, fileId, ext);
+  const buf = await getBytes(storageRef(storage, blobPath));
+  return Buffer.from(buf);
+}
+
+/**
+ * Read a blob and decode as UTF-8 text. Convenience for text/markdown
+ * callers.
+ */
+export async function readBlobAsText({ storage, orgId, fileId, ext }) {
+  const buf = await readBlob({ storage, orgId, fileId, ext });
+  return buf.toString('utf-8');
+}
+
+// ---- Folder-doc operations ----
+
+// Load all folder docs in this org for the given scope. Used by
+// ensureFolderChainInCloud to find or create folder docs along a
+// file's parent path. The result is small (folder count << file count)
+// so this query is cheap.
+async function loadScopedFolders({ filesRef, scope, teamId, userId }) {
+  let q;
+  if (scope === 'private') {
+    q = query(filesRef,
+      where('type', '==', 'folder'),
+      where('scope', '==', 'private'),
+      where('ownerId', '==', userId));
+  } else if (scope === 'team' && teamId) {
+    q = query(filesRef,
+      where('type', '==', 'folder'),
+      where('scope', '==', 'team'),
+      where('teamId', '==', teamId));
+  } else {
+    return [];
+  }
+  const snap = await getDocs(q);
+  const folders = [];
+  snap.forEach(d => folders.push({ id: d.id, ...d.data() }));
+  return folders;
+}
+
+// Apply a planFolderChain result against Firestore. Creates the
+// planned folder docs (rewriting tempId references to real ids) and
+// applies backfills. Returns the resolved leaf folder id (or null if
+// the input plan had no segments).
+async function applyFolderChainPlan({ filesRef, plan, now }) {
+  const tempToReal = new Map();
+  for (const create of plan.creates) {
+    const newRef = doc(filesRef);
+    const docData = {
+      ...create.doc,
+      parentId: tempToReal.get(create.doc.parentId) || create.doc.parentId,
+      createdAt: now,
+      updatedAt: now,
+    };
+    await setDoc(newRef, docData);
+    tempToReal.set(create.tempId, newRef.id);
+  }
+  for (const bf of plan.backfills) {
+    await updateDoc(doc(filesRef, bf.id), { path: bf.path, updatedAt: now });
+  }
+  if (plan.leafId == null) return null;
+  return tempToReal.get(plan.leafId) || plan.leafId;
+}
+
+/**
+ * Ensure folder docs exist for every segment of `docPath` and return
+ * the id of the leaf folder. Idempotent: existing folder docs are
+ * reused; missing ones are created; folder docs missing the `path`
+ * field are backfilled.
+ *
+ * `docPath` is the FULL slash-joined path of the folder itself (NOT a
+ * file path). Pass `'A/B'` to ensure both `A` and `A/B` exist; the
+ * returned id is for `A/B`.
+ *
+ * Returns null if `docPath` is empty (root).
+ */
+export async function ensureFolderChainInCloud({
+  filesRef,
+  scope,
+  teamId,
+  userId,
+  docPath,
+  now = new Date().toISOString(),
+}) {
+  if (scope === 'shared-with-me' || scope === 'shared-by-me') return null;
+  const segments = splitPath(docPath);
+  if (segments.length === 0) return null;
+
+  const existingFolders = await loadScopedFolders({ filesRef, scope, teamId, userId });
+  const plan = planFolderChain({
+    existingFolders,
+    segments,
+    scope,
+    teamId,
+    ownerId: scope === 'private' ? userId : null,
+  });
+  return applyFolderChainPlan({ filesRef, plan, now });
+}
+
+/**
+ * Find or create the folder doc at `docPath`. Convenience wrapper
+ * around ensureFolderChainInCloud for callers that want to upsert a
+ * folder explicitly (e.g., chokidar `addDir` events).
+ *
+ * Returns:
+ *   { action: 'skipped',        reason: 'shared-scope' }
+ *   { action: 'ensured',        folderId }
+ */
+export async function pushFolderToCloud({
+  filesRef,
+  scope,
+  teamId,
+  userId,
+  docPath,
+  now = new Date().toISOString(),
+}) {
+  if (scope === 'shared-with-me' || scope === 'shared-by-me') {
+    return { action: 'skipped', reason: 'shared-scope' };
+  }
+  const folderId = await ensureFolderChainInCloud({
+    filesRef, scope, teamId, userId, docPath, now,
+  });
+  return { action: 'ensured', folderId };
+}
+
+/**
+ * Delete the folder doc at `docPath` if it exists. Does NOT cascade
+ * to children (the sync daemon's `unlinkDir` event fires after its
+ * children's `unlink` events have already cleaned up child docs, so
+ * by the time we reach the folder it should be empty).
+ *
+ * Returns:
+ *   { action: 'skipped',   reason: 'shared-scope' }
+ *   { action: 'not-found' }
+ *   { action: 'deleted',   folderId }
+ */
+export async function deleteFolderFromCloud({
+  filesRef,
+  scope,
+  teamId,
+  userId,
+  docPath,
+}) {
+  if (scope === 'shared-with-me' || scope === 'shared-by-me') {
+    return { action: 'skipped', reason: 'shared-scope' };
+  }
+  let q;
+  if (scope === 'private') {
+    q = query(filesRef,
+      where('type', '==', 'folder'),
+      where('scope', '==', 'private'),
+      where('ownerId', '==', userId),
+      where('path', '==', docPath));
+  } else if (scope === 'team' && teamId) {
+    q = query(filesRef,
+      where('type', '==', 'folder'),
+      where('scope', '==', 'team'),
+      where('teamId', '==', teamId),
+      where('path', '==', docPath));
+  } else {
+    return { action: 'not-found' };
+  }
+  const snap = await getDocs(q);
+  if (snap.empty) return { action: 'not-found' };
+  const docSnap = snap.docs[0];
+  await deleteDoc(docSnap.ref);
+  return { action: 'deleted', folderId: docSnap.id };
+}
+
+// ---- High-level coordinator ----
+
+/**
+ * Push a file's content to the cloud: ensure the parent folder chain
+ * exists, upsert the Firestore metadata doc (with canonical fields
+ * including `type: 'file'`, `name`, `parentId`), and upload the blob.
+ *
+ * Args:
+ *   - data: the file's content. String, Buffer, or Uint8Array.
+ *   - mimeType: the file's mime type. Stored on the metadata doc and
+ *               used as the blob's Content-Type. Optional; if absent
+ *               for an existing file the existing mime is preserved,
+ *               and for new files defaults to 'text/markdown' to keep
+ *               legacy callers working.
+ *
+ * Returns one of:
+ *   { action: 'skipped', reason: 'shared-scope' }
+ *   { action: 'noop',    fileId }
+ *   { action: 'created', fileId, fileData, storageError? }
+ *   { action: 'updated', fileId, storageError? }
+ */
+export async function pushFileToCloud({
+  filesRef,
+  storage,
+  orgId,
+  userId,
+  scope,
+  teamId,
+  docPath,
+  data,
+  mimeType,
+  now = new Date().toISOString(),
+}) {
+  if (scope === 'shared-with-me' || scope === 'shared-by-me') {
+    return { action: 'skipped', reason: 'shared-scope' };
+  }
+
+  let snapshot;
+  if (scope === 'private') {
+    snapshot = await getDocs(query(filesRef,
+      where('scope', '==', 'private'),
+      where('ownerId', '==', userId),
+      where('path', '==', docPath)
+    ));
+  } else if (scope === 'team' && teamId) {
+    snapshot = await getDocs(query(filesRef,
+      where('scope', '==', 'team'),
+      where('teamId', '==', teamId),
+      where('path', '==', docPath)
+    ));
+  } else {
+    snapshot = await getDocs(query(filesRef, where('path', '==', docPath)));
+  }
+
+  const ext = extFromPath(docPath);
+  const contentHash = computeContentHash(data);
+  const size = contentByteSize(data);
+  const parts = splitPath(docPath);
+  const fileName = parts[parts.length - 1] || docPath;
+  // Parent folder docs must exist before we write the file doc so the
+  // file's `parentId` is a real folder id. ensureFolderChainInCloud
+  // is idempotent (existing folder docs are reused; missing ones are
+  // created with the canonical shape including `path`).
+  const parentFolderPath = parts.slice(0, -1).join('/');
+  const parentId = parentFolderPath
+    ? await ensureFolderChainInCloud({
+        filesRef,
+        scope,
+        teamId,
+        userId,
+        docPath: parentFolderPath,
+        now,
+      })
+    : null;
+
+  if (!snapshot || snapshot.empty) {
+    const newDocRef = doc(filesRef);
+    const fileId = newDocRef.id;
+    const resolvedMime = mimeType || 'text/markdown';
+    const fileData = {
+      type: 'file',
+      name: fileName,
+      parentId,
+      path: docPath,
+      createdAt: now,
+      updatedAt: now,
+      scope,
+      teamId: scope === 'team' ? (teamId || null) : null,
+      ownerId: scope === 'private' ? userId : null,
+      sharedWith: [],
+      storagePath: storagePathFor(orgId, fileId, ext),
+      contentHash,
+      size,
+      mimeType: resolvedMime,
+    };
+    await setDoc(newDocRef, fileData);
+    let storageError = null;
+    try {
+      await uploadBlob({ storage, orgId, fileId, ext, data, mimeType: resolvedMime });
+    } catch (err) {
+      storageError = err;
+    }
+    return { action: 'created', fileId, fileData, storageError };
+  }
+
+  const docSnap = snapshot.docs[0];
+  const existing = docSnap.data();
+  if (existing.contentHash === contentHash
+      && existing.type === 'file'
+      && existing.name === fileName
+      && (existing.parentId == null ? null : existing.parentId) === parentId) {
+    return { action: 'noop', fileId: docSnap.id };
+  }
+  const resolvedMime = mimeType || existing.mimeType || 'text/markdown';
+  await updateDoc(docSnap.ref, {
+    type: 'file',
+    name: fileName,
+    parentId,
+    updatedAt: now,
+    storagePath: storagePathFor(orgId, docSnap.id, ext),
+    contentHash,
+    size,
+    mimeType: resolvedMime,
+  });
+  let storageError = null;
+  try {
+    await uploadBlob({ storage, orgId, fileId: docSnap.id, ext, data, mimeType: resolvedMime });
+  } catch (err) {
+    storageError = err;
+  }
+  return { action: 'updated', fileId: docSnap.id, storageError };
+}
+
+/**
+ * Delete a file from Firestore and the corresponding Storage blob.
+ *
+ * Returns one of:
+ *   { action: 'skipped',        reason: 'shared-scope' }
+ *   { action: 'not-found' }
+ *   { action: 'deleted',        fileId }
+ *
+ * Blob deletion tolerates `storage/object-not-found`.
+ */
+export async function deleteFileFromCloud({
+  filesRef,
+  storage,
+  orgId,
+  userId,
+  scope,
+  teamId,
+  docPath,
+}) {
+  if (scope === 'shared-with-me' || scope === 'shared-by-me') {
+    return { action: 'skipped', reason: 'shared-scope' };
+  }
+
+  let snapshot;
+  if (scope === 'private') {
+    snapshot = await getDocs(query(
+      filesRef,
+      where('scope', '==', 'private'),
+      where('ownerId', '==', userId),
+      where('path', '==', docPath)
+    ));
+  } else if (scope === 'team' && teamId) {
+    snapshot = await getDocs(query(
+      filesRef,
+      where('scope', '==', 'team'),
+      where('teamId', '==', teamId),
+      where('path', '==', docPath)
+    ));
+  } else {
+    return { action: 'not-found' };
+  }
+
+  if (snapshot.empty) {
+    return { action: 'not-found' };
+  }
+  const docSnap = snapshot.docs[0];
+  const fileId = docSnap.id;
+  const ext = extFromPath(docPath);
+  // Delete the Storage blob FIRST while the metadata doc still exists,
+  // because the Storage rule's authorization check looks up the doc.
+  await deleteBlob({ storage, orgId, fileId, ext });
+  await deleteDoc(docSnap.ref);
+  return { action: 'deleted', fileId };
+}

package/folder-chain.js

@@ -0,0 +1,97 @@
+// Pure planner for folder-doc chains. Given a target path and the set
+// of folder docs that already exist in an org+scope, computes which
+// folder docs would need to be created so that every segment along
+// the path corresponds to a real folder doc with the canonical shape.
+//
+// Used by:
+//   - sync/files.js (server-side): before writing a file doc, walk
+//     its parent path and ensure folder docs exist. Returns the leaf
+//     folder's id (or null for root) so the caller can set
+//     `parentId` on the file doc.
+//   - sync/sync.js: when a directory appears locally, run the
+//     planner with `segments` set to the dir's path and apply.
+//
+// Pure: no I/O. Tests exercise it with synthetic inputs.
+
+export function splitPath(p) {
+  if (!p) return [];
+  return p.split('/').filter(Boolean);
+}
+
+function matchesScope(folder, { scope, teamId, ownerId }) {
+  if (folder.scope !== scope) return false;
+  const folderTeam = folder.teamId == null ? null : folder.teamId;
+  const wantTeam = teamId == null ? null : teamId;
+  if (folderTeam !== wantTeam) return false;
+  const folderOwner = folder.ownerId == null ? null : folder.ownerId;
+  const wantOwner = ownerId == null ? null : ownerId;
+  if (folderOwner !== wantOwner) return false;
+  return true;
+}
+
+// Plan the folder chain. Inputs:
+//   - existingFolders: array of folder docs from the org's files
+//     collection. Each has { id, type:'folder', name, parentId, path?,
+//     scope, teamId, ownerId, ... }.
+//   - segments: ordered path parts (no filename). For "A/B/file.md"
+//     the caller passes ['A', 'B']. For a folder doc itself at path
+//     "A/B", the caller passes ['A', 'B'].
+//   - scope, teamId, ownerId: the scope shape the folders must match.
+//
+// Returns:
+//   - creates: array of { tempId, doc } describing folder docs that
+//     would need to be created. Order is root-first; later items may
+//     reference earlier items' tempIds in their parentId field.
+//   - backfills: existing folder docs missing a `path` field, with
+//     the path they should be set to.
+//   - leafId: id of the leaf folder (the deepest segment), either a
+//     real id (if it existed) or a tempId (if planned for creation).
+//     null if `segments` is empty.
+export function planFolderChain({ existingFolders, segments, scope, teamId, ownerId }) {
+  const creates = [];
+  const backfills = [];
+
+  if (!segments || segments.length === 0) {
+    return { creates, backfills, leafId: null };
+  }
+
+  let parentId = null;
+  let pathSoFar = '';
+
+  for (const name of segments) {
+    pathSoFar = pathSoFar ? `${pathSoFar}/${name}` : name;
+
+    const existing = (existingFolders || []).find(f =>
+      f && f.type === 'folder'
+      && f.name === name
+      && (f.parentId == null ? null : f.parentId) === parentId
+      && matchesScope(f, { scope, teamId, ownerId })
+    );
+
+    if (existing) {
+      if (existing.path !== pathSoFar) {
+        backfills.push({ id: existing.id, path: pathSoFar });
+      }
+      parentId = existing.id;
+      continue;
+    }
+
+    const tempId = `__plan_folder_${creates.length}`;
+    creates.push({
+      tempId,
+      doc: {
+        type: 'folder',
+        name,
+        parentId,
+        path: pathSoFar,
+        scope,
+        teamId: scope === 'team' ? (teamId == null ? null : teamId) : null,
+        ownerId: scope === 'private' ? (ownerId == null ? null : ownerId) : null,
+        sharedWith: [],
+      },
+    });
+    parentId = tempId;
+  }
+
+  return { creates, backfills, leafId: parentId };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doubling/compound-sync",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "Bidirectional sync between Compound and local markdown files",
   "type": "module",
   "bin": {
@@ -10,13 +10,16 @@
     "sync.js",
     "config.js",
     "paths.js",
-    "dual-write.js",
+    "files.js",
+    "folder-chain.js",
+    "storage-helpers.js",
+    "team-registry.js",
     "README.md"
   ],
   "scripts": {
     "sync": "node sync.js",
-    "test:unit": "node --test config.test.js paths.test.js",
-    "test:integration": "firebase emulators:exec --only firestore,storage 'node --test dual-write.test.js'",
+    "test:unit": "node --test config.test.js paths.test.js storage-helpers.test.js folder-chain.test.js team-registry.test.js",
+    "test:integration": "firebase emulators:exec --only firestore,storage 'node --test files.test.js'",
     "test": "npm run test:unit && npm run test:integration"
   },
   "dependencies": {

package/storage-helpers.js

@@ -0,0 +1,88 @@
+// Pure Node-side storage helpers. No Firebase imports.
+//
+// Mirrors public/js/storage-helpers.js but uses Node-native APIs
+// (Buffer, crypto.createHash) instead of the browser equivalents
+// (Uint8Array, crypto.subtle). Function names and return types
+// match so that callers on either side can be reasoned about
+// uniformly.
+//
+// Storage layout convention:
+//   orgs/{orgId}/files/{fileId}/current.{ext}
+
+import crypto from 'crypto';
+
+export function extFromPath(path) {
+  const name = (((path == null ? '' : path) + '').split('/').pop()) || '';
+  const idx = name.lastIndexOf('.');
+  if (idx <= 0 || idx === name.length - 1) return 'bin';
+  return name.slice(idx + 1).toLowerCase();
+}
+
+export function storagePathFor(orgId, fileId, ext) {
+  return `orgs/${orgId}/files/${fileId}/current.${ext || 'bin'}`;
+}
+
+export function contentByteSize(data) {
+  if (data == null) return 0;
+  if (typeof data === 'string') return Buffer.byteLength(data, 'utf-8');
+  if (Buffer.isBuffer(data)) return data.length;
+  if (data instanceof Uint8Array) return data.byteLength;
+  if (data instanceof ArrayBuffer) return data.byteLength;
+  return Buffer.byteLength(String(data), 'utf-8');
+}
+
+export function computeContentHash(data) {
+  const buf = toBytes(data);
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+export function toBytes(data) {
+  if (data == null) return Buffer.alloc(0);
+  if (Buffer.isBuffer(data)) return data;
+  if (data instanceof Uint8Array) return Buffer.from(data);
+  if (data instanceof ArrayBuffer) return Buffer.from(data);
+  return Buffer.from(String(data), 'utf-8');
+}
+
+// Files with these mime types are treated as inline-readable text by
+// the sync daemon: read with utf-8 encoding from disk, written with
+// utf-8 encoding to disk. Everything else is treated as binary and
+// transferred as raw bytes.
+//
+// Missing mime type is treated as text for backward compatibility
+// with markdown files written before mimeType was tracked.
+export function isTextMimeType(mimeType) {
+  if (mimeType == null || mimeType === '') return true;
+  return typeof mimeType === 'string' && mimeType.startsWith('text/');
+}
+
+const EXT_TO_MIME = {
+  md: 'text/markdown',
+  markdown: 'text/markdown',
+  txt: 'text/plain',
+  csv: 'text/csv',
+  html: 'text/html',
+  htm: 'text/html',
+  css: 'text/css',
+  js: 'text/javascript',
+  json: 'application/json',
+  pdf: 'application/pdf',
+  png: 'image/png',
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  gif: 'image/gif',
+  webp: 'image/webp',
+  svg: 'image/svg+xml',
+  bmp: 'image/bmp',
+  mp3: 'audio/mpeg',
+  wav: 'audio/wav',
+  mp4: 'video/mp4',
+  webm: 'video/webm',
+  mov: 'video/quicktime',
+  zip: 'application/zip',
+};
+
+export function mimeTypeFromExt(ext) {
+  if (ext == null) return 'application/octet-stream';
+  return EXT_TO_MIME[String(ext).toLowerCase()] || 'application/octet-stream';
+}

package/sync.js

@@ -32,7 +32,20 @@ import os from 'os';
 import http from 'http';
 import { exec } from 'child_process';
 import { fileURLToPath } from 'url';
-import { pushFileToCloud, deleteFileFromCloud, readFileContent } from './dual-write.js';
+import {
+  pushFileToCloud,
+  deleteFileFromCloud,
+  pushFolderToCloud,
+  deleteFolderFromCloud,
+  readBlob,
+  readBlobAsText,
+  extFromPath,
+  isTextMimeType,
+  mimeTypeFromExt,
+} from './files.js';
+
+// Max file size enforced before upload. Mirrored in storage.rules.
+const MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
 import { resolveConfigPath, loadConfig, saveConfig } from './config.js';
 import {
   scopeFromLocalPath,
@@ -41,6 +54,7 @@ import {
   SHARED_WITH_ME_FOLDER,
   SHARED_BY_ME_FOLDER,
 } from './paths.js';
+import { TeamRegistry } from './team-registry.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -555,25 +569,34 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
   const LOCAL_PATH = expandHome(rawLocalPath);
   const filesRef = collection(db, `orgs/${orgId}/files`);
 
-  const teams = new Map();
-  const teamIdsByName = new Map();
   const lastKnownUpdate = new Map();
   const suppressLocal = new Set();
-
-  async function loadTeams() {
-    const snapshot = await getDocs(collection(db, `orgs/${orgId}/teams`));
-    snapshot.forEach(d => {
-      const data = d.data();
-      teams.set(d.id, data);
-      teamIdsByName.set(data.name, d.id);
-    });
+  // Per-team Firestore-listener unsubscribe handles, keyed by teamId.
+  // The TeamRegistry's onSetup populates this; onTeardown calls and
+  // drops the entry so a removed teamspace stops pulling files.
+  const teamUnsubscribers = new Map();
+  // Hoisted forward-decl: setupTeam closes over handleFirestoreChange,
+  // which is defined later in this function. Wired below.
+  let setupTeam = () => {};
+  function teardownTeam(teamId, teamData) {
+    const unsub = teamUnsubscribers.get(teamId);
+    if (unsub) {
+      try { unsub(); } catch (e) { /* ignore */ }
+      teamUnsubscribers.delete(teamId);
+      const folder = teamData && teamData.name ? teamFolderName(teamData.name) : teamId;
+      console.log(`  [${orgId}]   Stopped listening: ${folder}`);
+    }
   }
-
-  await loadTeams();
+  const teamRegistry = new TeamRegistry({
+    onSetup: (teamId, teamData) => setupTeam(teamId, teamData),
+    onTeardown: teardownTeam,
+  });
+  // scopeFromLocalPath expects a Map<teamName, teamId>; the registry
+  // exposes one matching that shape.
+  const teamIdsByName = teamRegistry.teamIdsByName;
 
   console.log('');
   console.log(`  [${orgId}] Local: ${LOCAL_PATH}`);
-  console.log(`  [${orgId}] Teams: ${[...teams.values()].map(t => t.name).join(', ') || 'none'}`);
 
   function ensureDir(filePath) {
     const dir = path.dirname(filePath);
@@ -608,6 +631,8 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
     }
   }
 
+  // Static (user-level) folders. Team folders are created per-team by
+  // setupTeam below as soon as the registry sees each teamspace.
   function ensureFolderStructure() {
     const privatePath = path.join(LOCAL_PATH, PRIVATE_FOLDER);
     if (!fs.existsSync(privatePath)) fs.mkdirSync(privatePath, { recursive: true });
@@ -617,11 +642,6 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
 
     const sharedByMePath = path.join(LOCAL_PATH, SHARED_BY_ME_FOLDER);
     if (!fs.existsSync(sharedByMePath)) fs.mkdirSync(sharedByMePath, { recursive: true });
-
-    for (const [, teamData] of teams) {
-      const teamPath = path.join(LOCAL_PATH, teamFolderName(teamData.name));
-      if (!fs.existsSync(teamPath)) fs.mkdirSync(teamPath, { recursive: true });
-    }
   }
 
   ensureFolderStructure();
@@ -633,9 +653,26 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
 
     const localFilePath = getLocalPath(data);
     const trackingKey = `${data.scope || 'team'}:${docPath}`;
+    const isFolder = data.type === 'folder';
 
     if (change.type === 'removed') {
-      if (fs.existsSync(localFilePath)) {
+      if (isFolder) {
+        // Best-effort directory removal. The daemon's own file-delete
+        // events should have cleared all children by the time we get
+        // here; if not, rmdirSync throws ENOTEMPTY and we keep the
+        // directory rather than risk losing data the user hasn't seen.
+        try {
+          suppressLocal.add(localFilePath);
+          fs.rmdirSync(localFilePath);
+          console.log(`  [${orgId}] [firestore → local] RMDIR ${docPath}`);
+          setTimeout(() => suppressLocal.delete(localFilePath), 1000);
+        } catch (err) {
+          suppressLocal.delete(localFilePath);
+          if (err.code !== 'ENOENT' && err.code !== 'ENOTEMPTY') {
+            console.error(`  [${orgId}] [firestore → local] RMDIR ${docPath} failed: ${err.message}`);
+          }
+        }
+      } else if (fs.existsSync(localFilePath)) {
         console.log(`  [${orgId}] [firestore → local] DELETE ${docPath}`);
         suppressLocal.add(localFilePath);
         fs.unlinkSync(localFilePath);
@@ -649,6 +686,19 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
     const lastKnown = lastKnownUpdate.get(trackingKey);
     if (lastKnown && lastKnown >= remoteUpdated) return;
 
+    if (isFolder) {
+      // Folder docs mirror to a local directory. No blob, no content
+      // comparison; if the directory doesn't exist yet, create it.
+      if (!fs.existsSync(localFilePath)) {
+        suppressLocal.add(localFilePath);
+        fs.mkdirSync(localFilePath, { recursive: true });
+        console.log(`  [${orgId}] [firestore → local] MKDIR ${docPath}`);
+        setTimeout(() => suppressLocal.delete(localFilePath), 1000);
+      }
+      lastKnownUpdate.set(trackingKey, remoteUpdated);
+      return;
+    }
+
     if (fs.existsSync(localFilePath)) {
       const localMtime = fs.statSync(localFilePath).mtime.toISOString();
       if (localMtime > remoteUpdated) return;
@@ -659,31 +709,80 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
     ensureDir(localFilePath);
     suppressLocal.add(localFilePath);
 
-    const content = await readFileContent({
-      storage,
-      orgId,
-      fileId: change.doc.id,
-    });
-    fs.writeFileSync(localFilePath, content || '', 'utf-8');
+    const ext = extFromPath(docPath);
+    if (isTextMimeType(data.mimeType)) {
+      const content = await readBlobAsText({
+        storage,
+        orgId,
+        fileId: change.doc.id,
+        ext,
+      });
+      fs.writeFileSync(localFilePath, content || '', 'utf-8');
+    } else {
+      const bytes = await readBlob({
+        storage,
+        orgId,
+        fileId: change.doc.id,
+        ext,
+      });
+      fs.writeFileSync(localFilePath, bytes);
+    }
     lastKnownUpdate.set(trackingKey, remoteUpdated);
     setTimeout(() => suppressLocal.delete(localFilePath), 1000);
   }
 
-  function startFirestoreListeners() {
-    console.log(`  [${orgId}] Starting Firestore listeners...`);
+  // Set up per-team resources: mkdir the local folder, register the
+  // Firestore listener for that team's files. Wired into the
+  // TeamRegistry; called once per teamspace as it appears.
+  setupTeam = (teamId, teamData) => {
+    const teamFolder = teamFolderName(teamData.name);
+    const teamPath = path.join(LOCAL_PATH, teamFolder);
+    if (!fs.existsSync(teamPath)) fs.mkdirSync(teamPath, { recursive: true });
+
+    const q = query(filesRef, where('scope', '==', 'team'), where('teamId', '==', teamId));
+    const unsubscribe = onSnapshot(q, snapshot => {
+      snapshot.docChanges().forEach(change => {
+        handleFirestoreChange(change, data =>
+          path.join(LOCAL_PATH, teamFolder, data.path),
+        ).catch(err => console.error(`  [${orgId}] Firestore change handler error:`, err && err.message));
+      });
+    }, err => console.error(`  [${orgId}] Team "${teamFolder}" listener error:`, err));
+
+    teamUnsubscribers.set(teamId, unsubscribe);
+    console.log(`  [${orgId}]   Listening: ${teamFolder}`);
+  };
 
-    for (const [teamId, teamData] of teams) {
-      const teamFolder = teamFolderName(teamData.name);
-      const q = query(filesRef, where('scope', '==', 'team'), where('teamId', '==', teamId));
-      onSnapshot(q, snapshot => {
-        snapshot.docChanges().forEach(change => {
-          handleFirestoreChange(change, data =>
-            path.join(LOCAL_PATH, teamFolder, data.path),
-          ).catch(err => console.error(`  [${orgId}] Firestore change handler error:`, err && err.message));
+  // Live listener on the teams collection. Initial snapshot bootstraps
+  // the known teamspaces; subsequent changes pick up new/renamed/
+  // removed teamspaces without restarting the daemon. We await the
+  // first snapshot so the local watcher sees a populated teamIdsByName
+  // before it tries to route any addDir/add events.
+  await new Promise((resolve, reject) => {
+    let firstSnapshotResolved = false;
+    onSnapshot(collection(db, `orgs/${orgId}/teams`), (snapshot) => {
+      snapshot.docChanges().forEach((change) => {
+        teamRegistry.applyChange({
+          type: change.type,
+          id: change.doc.id,
+          data: change.doc.data(),
         });
-      }, err => console.error(`  [${orgId}] Team "${teamFolder}" listener error:`, err));
-      console.log(`  [${orgId}]   Listening: ${teamFolder}`);
-    }
+      });
+      if (!firstSnapshotResolved) {
+        firstSnapshotResolved = true;
+        console.log(`  [${orgId}] Teams: ${teamRegistry.names().join(', ') || 'none'}`);
+        resolve();
+      }
+    }, (err) => {
+      console.error(`  [${orgId}] Teams listener error:`, err);
+      if (!firstSnapshotResolved) {
+        firstSnapshotResolved = true;
+        reject(err);
+      }
+    });
+  });
+
+  function startFirestoreListeners() {
+    console.log(`  [${orgId}] Starting Firestore listeners...`);
 
     if (USER_ID) {
       const privateQ = query(filesRef, where('scope', '==', 'private'), where('ownerId', '==', USER_ID));
@@ -719,7 +818,7 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
     }
   }
 
-  async function pushToFirestore(filePath, content) {
+  async function pushToFirestore(filePath, data, mimeType) {
     const { scope, teamId, docPath } = scopeFromLocalPath(filePath, LOCAL_PATH, teamIdsByName);
     const trackingKey = `${scope}:${docPath}`;
     const now = new Date().toISOString();
@@ -733,12 +832,13 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
       scope,
       teamId,
       docPath,
-      content,
+      data,
+      mimeType,
       now,
     });
 
     if (result.action === 'created') {
-      console.log(`  [${orgId}] [local → firestore] CREATE ${docPath} (${scope})`);
+      console.log(`  [${orgId}] [local → firestore] CREATE ${docPath} (${scope}, ${mimeType})`);
     } else if (result.action === 'updated') {
       console.log(`  [${orgId}] [local → firestore] UPDATE ${docPath} (${scope})`);
     }
@@ -767,17 +867,112 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
     }
   }
 
+  // Determine whether a local path corresponds to a syncable directory.
+  // Excludes the scope-root directories themselves (Private, Shared
+  // with Me, Shared by Me, and the per-team roots) since those are
+  // managed by ensureFolderStructure, not the user.
+  function isSyncableLocalDir(rel) {
+    if (!rel) return false;
+    if (rel === PRIVATE_FOLDER || rel === SHARED_WITH_ME_FOLDER || rel === SHARED_BY_ME_FOLDER) {
+      return false;
+    }
+    if (rel.startsWith(SHARED_WITH_ME_FOLDER + path.sep)) return false;
+    if (rel.startsWith(SHARED_BY_ME_FOLDER + path.sep)) return false;
+    const parts = rel.split(path.sep);
+    // A bare team root (e.g. "Engineering Teamspace") corresponds to
+    // the scope root, not a subdirectory. Skip these.
+    if (parts.length === 1 && parts[0].endsWith(' Teamspace')) return false;
+    return true;
+  }
+
+  async function pushDirToFirestore(dirPath) {
+    const { scope, teamId, docPath } = scopeFromLocalPath(dirPath, LOCAL_PATH, teamIdsByName);
+    if (!docPath) return; // scope root
+    const trackingKey = `${scope}:${docPath}`;
+    const now = new Date().toISOString();
+    lastKnownUpdate.set(trackingKey, now);
+
+    const result = await pushFolderToCloud({
+      filesRef,
+      scope,
+      teamId,
+      userId: USER_ID,
+      docPath,
+      now,
+    });
+
+    if (result.action === 'ensured' && result.folderId) {
+      console.log(`  [${orgId}] [local → firestore] FOLDER ${docPath} (${scope})`);
+    }
+  }
+
+  async function deleteDirFromFirestore(dirPath) {
+    const { scope, teamId, docPath } = scopeFromLocalPath(dirPath, LOCAL_PATH, teamIdsByName);
+    if (!docPath) return;
+    const trackingKey = `${scope}:${docPath}`;
+    lastKnownUpdate.delete(trackingKey);
+
+    const result = await deleteFolderFromCloud({
+      filesRef,
+      scope,
+      teamId,
+      userId: USER_ID,
+      docPath,
+    });
+
+    if (result.action === 'deleted') {
+      console.log(`  [${orgId}] [local → firestore] RMFOLDER ${docPath} (${scope})`);
+    }
+  }
+
   function handleLocalChange(filePath) {
     if (suppressLocal.has(filePath)) return;
 
     const rel = path.relative(LOCAL_PATH, filePath);
-    if (!rel.endsWith('.md') && !rel.endsWith('.txt')) return;
-
     if (rel.startsWith(SHARED_WITH_ME_FOLDER + path.sep)) return;
     if (rel.startsWith(SHARED_BY_ME_FOLDER + path.sep)) return;
 
-    const content = fs.readFileSync(filePath, 'utf-8');
-    pushToFirestore(filePath, content).catch(err => console.error(`  [${orgId}] Push error: ${err.message}`));
+    let stat;
+    try {
+      stat = fs.statSync(filePath);
+    } catch (err) {
+      return; // disappeared between event and read
+    }
+    if (!stat.isFile()) return;
+    if (stat.size > MAX_UPLOAD_BYTES) {
+      console.error(`  [${orgId}] [skip] ${rel} exceeds ${MAX_UPLOAD_BYTES} byte cap (${stat.size} bytes)`);
+      return;
+    }
+
+    const ext = extFromPath(rel);
+    const mimeType = mimeTypeFromExt(ext);
+    // Text files: read as a UTF-8 string so future text-aware features
+    // (line-level diffing, conflict markers) can work. Binary files:
+    // read as a Buffer so bytes round-trip without corruption.
+    const data = isTextMimeType(mimeType)
+      ? fs.readFileSync(filePath, 'utf-8')
+      : fs.readFileSync(filePath);
+    pushToFirestore(filePath, data, mimeType).catch(err =>
+      console.error(`  [${orgId}] Push error: ${err.message}`)
+    );
+  }
+
+  function handleLocalDirAdded(dirPath) {
+    if (suppressLocal.has(dirPath)) return;
+    const rel = path.relative(LOCAL_PATH, dirPath);
+    if (!isSyncableLocalDir(rel)) return;
+    pushDirToFirestore(dirPath).catch(err =>
+      console.error(`  [${orgId}] Folder push error for ${rel}: ${err.message}`)
+    );
+  }
+
+  function handleLocalDirRemoved(dirPath) {
+    if (suppressLocal.has(dirPath)) return;
+    const rel = path.relative(LOCAL_PATH, dirPath);
+    if (!isSyncableLocalDir(rel)) return;
+    deleteDirFromFirestore(dirPath).catch(err =>
+      console.error(`  [${orgId}] Folder delete error for ${rel}: ${err.message}`)
+    );
   }
 
   function startLocalWatcher() {
@@ -806,6 +1001,8 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
       if (suppressLocal.has(filePath)) return;
       deleteFromFirestore(filePath).catch(err => console.error(`  [${orgId}] Delete error: ${err.message}`));
     });
+    watcher.on('addDir', dirPath => handleLocalDirAdded(dirPath));
+    watcher.on('unlinkDir', dirPath => handleLocalDirRemoved(dirPath));
 
     watcher.on('ready', () => console.log(`  [${orgId}] Local watcher ready.`));
   }

package/team-registry.js

@@ -0,0 +1,94 @@
+// Pure state machine for tracking which teamspaces the sync daemon
+// is currently watching. The daemon used to enumerate teams once at
+// startup and statically register a Firestore listener for each; this
+// missed any teamspaces created later (e.g. via the web's "+ New
+// Teamspace" button) until the daemon was restarted.
+//
+// TeamRegistry owns the in-memory map of teamId -> teamData and
+// dispatches setup/teardown callbacks when the desired team set
+// changes. The actual side effects (mkdir, onSnapshot, unsubscribe)
+// live in the caller and are passed in as `onSetup` / `onTeardown`.
+// This keeps the dispatch logic testable without mocking Firestore.
+//
+// Usage:
+//   const registry = new TeamRegistry({
+//     onSetup: (teamId, teamData) => { ... },
+//     onTeardown: (teamId, teamData) => { ... },
+//   });
+//   // For each docChange from onSnapshot on the teams collection:
+//   registry.applyChange({ type: 'added', id, data });
+
+export class TeamRegistry {
+  constructor({ onSetup, onTeardown }) {
+    this.teams = new Map(); // teamId -> teamData
+    this.teamIdsByName = new Map(); // teamName -> teamId
+    this.onSetup = onSetup;
+    this.onTeardown = onTeardown;
+  }
+
+  // Idempotently register a team. Safe to call with the same team
+  // multiple times; only the first call triggers onSetup.
+  add(teamId, teamData) {
+    if (this.teams.has(teamId)) return false;
+    this.teams.set(teamId, teamData);
+    if (teamData && teamData.name) {
+      this.teamIdsByName.set(teamData.name, teamId);
+    }
+    this.onSetup(teamId, teamData);
+    return true;
+  }
+
+  // Update a team's metadata. If the team's name changed, treat as a
+  // rename: teardown the old listener, register a new one (which
+  // creates a new local folder under the new name). The old folder
+  // is intentionally NOT renamed or removed; the user can clean it
+  // up manually. This is conservative; a rename-aware implementation
+  // is a follow-up.
+  modify(teamId, teamData) {
+    const prev = this.teams.get(teamId);
+    if (!prev) {
+      // Treat modify-of-unknown as an add. Firestore emits both
+      // 'added' and 'modified' for the same doc under certain
+      // listener-restart scenarios, so we want this path resilient.
+      return this.add(teamId, teamData);
+    }
+    this.teams.set(teamId, teamData);
+    const renamed = prev.name !== (teamData && teamData.name);
+    if (renamed) {
+      if (prev.name) this.teamIdsByName.delete(prev.name);
+      if (teamData && teamData.name) {
+        this.teamIdsByName.set(teamData.name, teamId);
+      }
+      this.onTeardown(teamId, prev);
+      this.onSetup(teamId, teamData);
+    }
+    return renamed;
+  }
+
+  // Remove a team (e.g., user lost membership). Tears down the
+  // listener; leaves any local folder alone.
+  remove(teamId) {
+    const prev = this.teams.get(teamId);
+    if (!prev) return false;
+    this.teams.delete(teamId);
+    if (prev.name) this.teamIdsByName.delete(prev.name);
+    this.onTeardown(teamId, prev);
+    return true;
+  }
+
+  // Convenience: dispatch a Firestore docChange into add/modify/remove.
+  applyChange({ type, id, data }) {
+    if (type === 'added') return this.add(id, data);
+    if (type === 'modified') return this.modify(id, data);
+    if (type === 'removed') return this.remove(id);
+    return false;
+  }
+
+  // Read-only accessors for the daemon's existing call sites.
+  has(teamId) { return this.teams.has(teamId); }
+  get(teamId) { return this.teams.get(teamId); }
+  getIdByName(teamName) { return this.teamIdsByName.get(teamName); }
+  size() { return this.teams.size; }
+  entries() { return this.teams.entries(); }
+  names() { return [...this.teams.values()].map(t => t.name).filter(Boolean); }
+}

package/dual-write.js

@@ -1,226 +0,0 @@
-// Dual-write helpers for the sync daemon and integration tests.
-//
-// Each function takes its dependencies (filesRef, storage, orgId, etc.)
-// as parameters so the logic is importable into a test harness that
-// provides emulator-backed Firebase handles. The sync daemon (sync.js)
-// is the production caller and supplies real-Firebase handles.
-//
-// Side effect ordering on writes:
-//   1. Write the Firestore metadata document (Storage rules require
-//      the metadata doc to exist before the upload is authorized).
-//   2. Upload the blob to Cloud Storage at the deterministic path
-//      derived from orgId + fileId.
-//   3. Storage failures are returned in the result, not thrown, so the
-//      caller can decide whether to surface as a soft warning while the
-//      Firestore content field still holds the up-to-date value.
-
-import crypto from 'crypto';
-import {
-  doc, getDocs, setDoc, updateDoc, deleteDoc, query, where,
-} from 'firebase/firestore';
-import {
-  ref as storageRef, uploadString, deleteObject, getBytes,
-} from 'firebase/storage';
-
-// ---- Pure helpers ----
-
-export function computeContentHash(content) {
-  return crypto.createHash('sha256').update(content || '', 'utf-8').digest('hex');
-}
-
-export function storagePathFor(orgId, fileId) {
-  return `orgs/${orgId}/files/${fileId}/current.md`;
-}
-
-// ---- Storage primitives ----
-
-export async function uploadBlob({ storage, orgId, fileId, content }) {
-  const blobPath = storagePathFor(orgId, fileId);
-  await uploadString(storageRef(storage, blobPath), content || '', 'raw', {
-    contentType: 'text/markdown',
-  });
-}
-
-export async function deleteBlob({ storage, orgId, fileId }) {
-  const blobPath = storagePathFor(orgId, fileId);
-  try {
-    await deleteObject(storageRef(storage, blobPath));
-  } catch (err) {
-    if (err && err.code === 'storage/object-not-found') {
-      return; // tolerate missing blob (older files written before PR 2)
-    }
-    throw err;
-  }
-}
-
-/**
- * Read file content from Cloud Storage. Throws on any failure
- * (missing blob, permission error, network). The Firestore content
- * field is no longer written or read as of PR 6, so the read path
- * has no fallback. Backfill (PR 4) is a prerequisite.
- */
-export async function readFileContent({ storage, orgId, fileId }) {
-  const blobPath = storagePathFor(orgId, fileId);
-  const bytes = await getBytes(storageRef(storage, blobPath));
-  return new TextDecoder('utf-8').decode(new Uint8Array(bytes));
-}
-
-// ---- Core dual-write ----
-
-/**
- * Write a file's content to Cloud Storage at
- * orgs/{orgId}/files/{fileId}/current.md and update the Firestore
- * metadata doc with storagePath/contentHash/size. As of PR 6 the
- * Firestore `content` field is no longer written; the blob is the
- * sole source of file content.
- *
- * Returns one of:
- *   { action: 'skipped', reason: 'shared-scope' }
- *   { action: 'noop',    fileId }
- *   { action: 'created', fileId, fileData, storageError? }
- *   { action: 'updated', fileId, storageError? }
- *
- * `storageError` is populated when the Firestore write succeeded but
- * the Storage upload failed. Callers should log and retry; the next
- * save attempts the upload again.
- */
-export async function pushFileToCloud({
-  filesRef,
-  storage,
-  orgId,
-  userId,
-  scope,
-  teamId,
-  docPath,
-  content,
-  now = new Date().toISOString(),
-}) {
-  if (scope === 'shared-with-me' || scope === 'shared-by-me') {
-    return { action: 'skipped', reason: 'shared-scope' };
-  }
-
-  let snapshot;
-  if (scope === 'private') {
-    snapshot = await getDocs(query(filesRef,
-      where('scope', '==', 'private'),
-      where('ownerId', '==', userId),
-      where('path', '==', docPath)
-    ));
-  } else if (scope === 'team' && teamId) {
-    snapshot = await getDocs(query(filesRef,
-      where('scope', '==', 'team'),
-      where('teamId', '==', teamId),
-      where('path', '==', docPath)
-    ));
-  } else {
-    snapshot = await getDocs(query(filesRef, where('path', '==', docPath)));
-  }
-
-  const contentHash = computeContentHash(content);
-  const size = Buffer.byteLength(content || '', 'utf-8');
-
-  if (!snapshot || snapshot.empty) {
-    const newDocRef = doc(filesRef);
-    const fileId = newDocRef.id;
-    const fileData = {
-      path: docPath,
-      createdAt: now,
-      updatedAt: now,
-      scope,
-      teamId: scope === 'team' ? (teamId || null) : null,
-      ownerId: scope === 'private' ? userId : null,
-      sharedWith: [],
-      storagePath: storagePathFor(orgId, fileId),
-      contentHash,
-      size,
-    };
-    await setDoc(newDocRef, fileData);
-    let storageError = null;
-    try {
-      await uploadBlob({ storage, orgId, fileId, content });
-    } catch (err) {
-      storageError = err;
-    }
-    return { action: 'created', fileId, fileData, storageError };
-  }
-
-  const docSnap = snapshot.docs[0];
-  const existing = docSnap.data();
-  if (existing.contentHash === contentHash) {
-    return { action: 'noop', fileId: docSnap.id };
-  }
-  await updateDoc(docSnap.ref, {
-    updatedAt: now,
-    storagePath: storagePathFor(orgId, docSnap.id),
-    contentHash,
-    size,
-  });
-  let storageError = null;
-  try {
-    await uploadBlob({ storage, orgId, fileId: docSnap.id, content });
-  } catch (err) {
-    storageError = err;
-  }
-  return { action: 'updated', fileId: docSnap.id, storageError };
-}
-
-/**
- * Delete a file from Firestore and the corresponding Storage blob.
- *
- * Returns one of:
- *   { action: 'skipped',        reason: 'shared-scope' }
- *   { action: 'not-found' }
- *   { action: 'scope-mismatch' }
- *   { action: 'deleted',        fileId }
- *
- * Blob deletion tolerates `storage/object-not-found`.
- */
-export async function deleteFileFromCloud({
-  filesRef,
-  storage,
-  orgId,
-  userId,
-  scope,
-  teamId,
-  docPath,
-}) {
-  if (scope === 'shared-with-me' || scope === 'shared-by-me') {
-    return { action: 'skipped', reason: 'shared-scope' };
-  }
-
-  // The list query must mirror the Firestore rule's per-branch
-  // constraints (scope + ownerId for private, scope + teamId for team)
-  // so the rules engine can statically authorize it.
-  let snapshot;
-  if (scope === 'private') {
-    snapshot = await getDocs(query(
-      filesRef,
-      where('scope', '==', 'private'),
-      where('ownerId', '==', userId),
-      where('path', '==', docPath)
-    ));
-  } else if (scope === 'team' && teamId) {
-    snapshot = await getDocs(query(
-      filesRef,
-      where('scope', '==', 'team'),
-      where('teamId', '==', teamId),
-      where('path', '==', docPath)
-    ));
-  } else {
-    return { action: 'not-found' };
-  }
-
-  if (snapshot.empty) {
-    return { action: 'not-found' };
-  }
-  const docSnap = snapshot.docs[0];
-  const fileId = docSnap.id;
-  // Delete the Storage blob FIRST while the metadata doc still exists,
-  // because the Storage rule's authorization check looks up the doc.
-  // After Firestore deletion the rule would deny (firestore.get fails).
-  // deleteBlob tolerates storage/object-not-found for files that were
-  // written before PR 2 and so have no blob.
-  await deleteBlob({ storage, orgId, fileId });
-  await deleteDoc(docSnap.ref);
-  return { action: 'deleted', fileId };
-}