@doubling/compound-sync 1.12.3 → 1.12.5

package/files.js

@@ -24,141 +24,114 @@
 //   1. Delete the Storage blob (while metadata still exists so the
 //      Storage rule can authorize).
 //   2. Delete the Firestore metadata document.
-
-import {
-  doc, getDoc, getDocs, setDoc, updateDoc, deleteDoc, query, where,
-} from 'firebase/firestore';
-import {
-  ref as storageRef, uploadBytes, deleteObject, getBytes,
-} from 'firebase/storage';
-
-import {
-  storagePathFor,
-  extFromPath,
-  contentByteSize,
-  computeContentHash,
-  folderDocId,
-  fileDocId,
-  toBytes,
-} from './storage-helpers.js';
-import { planFolderChain, splitPath } from './folder-chain.js';
-
+import { doc, getDoc, getDocs, setDoc, updateDoc, deleteDoc, query, where, } from 'firebase/firestore';
+import { ref as storageRef, uploadBytes, deleteObject, getBytes, } from 'firebase/storage';
+import { storagePathFor, extFromPath, contentByteSize, computeContentHash, folderDocId, fileDocId, 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';
-
+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',
-  });
+    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;
-  }
+    const blobPath = storagePathFor(orgId, fileId, ext);
+    try {
+        await deleteObject(storageRef(storage, blobPath));
+    }
+    catch (err) {
+        if (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);
+    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');
+export async function readBlobAsText(input) {
+    const buf = await readBlob(input);
+    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;
+    let q;
+    if (scope === 'private') {
+        if (!userId) {
+            throw new Error('loadScopedFolders: userId is required for private scope');
+        }
+        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) {
-    // Deterministic id by {scope, teamId, ownerId, path}; concurrent
-    // sibling creates for the same path collapse onto the same doc
-    // instead of producing duplicates (DOU-240).
-    const realId = folderDocId({
-      scope: create.doc.scope,
-      teamId: create.doc.teamId,
-      ownerId: create.doc.ownerId,
-      path: create.doc.path,
-    });
-    const newRef = doc(filesRef, realId);
-    const docData = {
-      ...create.doc,
-      parentId: tempToReal.get(create.doc.parentId) || create.doc.parentId,
-      createdAt: now,
-      updatedAt: now,
-    };
-    // setDoc with merge:false is idempotent on identical input; the
-    // last writer wins on differing fields. For folder docs the only
-    // fields that vary between concurrent callers are timestamps, so
-    // any tie-break is acceptable.
-    await setDoc(newRef, docData);
-    tempToReal.set(create.tempId, realId);
-  }
-  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;
+    const tempToReal = new Map();
+    for (const create of plan.creates) {
+        // Deterministic id by {scope, teamId, ownerId, path}; concurrent
+        // sibling creates for the same path collapse onto the same doc
+        // instead of producing duplicates (DOU-240).
+        const realId = folderDocId({
+            scope: create.doc.scope,
+            teamId: create.doc.teamId,
+            ownerId: create.doc.ownerId,
+            path: create.doc.path,
+        });
+        const newRef = doc(filesRef, realId);
+        const resolvedParentId = create.doc.parentId == null
+            ? null
+            : (tempToReal.get(create.doc.parentId) ?? create.doc.parentId);
+        const docData = {
+            ...create.doc,
+            parentId: resolvedParentId,
+            createdAt: now,
+            updatedAt: now,
+        };
+        // setDoc with merge:false is idempotent on identical input; the
+        // last writer wins on differing fields. For folder docs the only
+        // fields that vary between concurrent callers are timestamps, so
+        // any tie-break is acceptable.
+        await setDoc(newRef, docData);
+        tempToReal.set(create.tempId, realId);
+    }
+    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
@@ -171,29 +144,22 @@ async function applyFolderChainPlan({ filesRef, plan, now }) {
  *
  * 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 });
+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) : 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
@@ -203,23 +169,15 @@ export async function ensureFolderChainInCloud({
  *   { 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 };
+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` AND every descendant (files and
  * sub-folders) in the same scope. Cascade is authoritative: it does
@@ -243,95 +201,89 @@ export async function pushFolderToCloud({
  *   { action: 'not-found' }
  *   { action: 'deleted',   folderId, childCount }
  */
-export async function deleteFolderFromCloud({
-  filesRef,
-  storage,
-  orgId,
-  scope,
-  teamId,
-  userId,
-  docPath,
-}) {
-  if (scope === 'shared-with-me' || scope === 'shared-by-me') {
-    return { action: 'skipped', reason: 'shared-scope' };
-  }
-  // Pull every doc in this scope; cheap because vaults are small
-  // (hundreds of docs at most). Filtering in memory avoids the
-  // Firestore composite-index requirement for a path-prefix range
-  // query and keeps the cascade contract dead simple to reason about.
-  let scopeQuery;
-  if (scope === 'private') {
-    scopeQuery = query(filesRef,
-      where('scope', '==', 'private'),
-      where('ownerId', '==', userId));
-  } else if (scope === 'team' && teamId) {
-    scopeQuery = query(filesRef,
-      where('scope', '==', 'team'),
-      where('teamId', '==', teamId));
-  } else {
-    return { action: 'not-found' };
-  }
-  const snap = await getDocs(scopeQuery);
-
-  const prefix = docPath + '/';
-  let folderDocSnap = null;
-  const descendants = [];
-  snap.forEach((d) => {
-    const data = d.data();
-    const p = data.path;
-    if (!p) return;
-    if (data.type === 'folder' && p === docPath) {
-      folderDocSnap = d;
-    } else if (p.startsWith(prefix)) {
-      descendants.push({ id: d.id, ref: d.ref, data });
-    }
-  });
-
-  if (!folderDocSnap && descendants.length === 0) {
-    return { action: 'not-found' };
-  }
-
-  // Delete each descendant's blob (files only) then its doc.
-  for (const { id, ref, data } of descendants) {
-    if (data.type !== 'folder') {
-      const ext = extFromPath(data.path);
-      // Re-check the doc still exists right before calling the
-      // Storage SDK. If a concurrent caller (chokidar's per-file
-      // unlink fan-out, or another cascade) already deleted the
-      // metadata doc, the Storage rule's cross-service
-      // firestore.get(...).data.scope reads null and throws "Null
-      // value error", and the Storage SDK retries for several
-      // seconds before surfacing storage/unauthorized. The retry
-      // latency is what blew the test budget on DOU-242 + DOU-251.
-      // Skipping the SDK call avoids both the rule throw and the
-      // retry; the orphan blob (if any) is cleaned up by the
-      // data-integrity audit (DOU-244).
-      const recheck = await getDoc(ref);
-      if (recheck.exists()) {
-        try {
-          await deleteBlob({ storage, orgId, fileId: id, ext });
-        } catch (err) {
-          // Orphan blob is a soft failure; the doc delete is the
-          // load-bearing state transition for the user's view.
+export async function deleteFolderFromCloud({ filesRef, storage, orgId, scope, teamId, userId, docPath, }) {
+    if (scope === 'shared-with-me' || scope === 'shared-by-me') {
+        return { action: 'skipped', reason: 'shared-scope' };
+    }
+    // Pull every doc in this scope; cheap because vaults are small
+    // (hundreds of docs at most). Filtering in memory avoids the
+    // Firestore composite-index requirement for a path-prefix range
+    // query and keeps the cascade contract dead simple to reason about.
+    let scopeQuery;
+    if (scope === 'private') {
+        if (!userId) {
+            throw new Error('deleteFolderFromCloud: userId is required for private scope');
+        }
+        scopeQuery = query(filesRef, where('scope', '==', 'private'), where('ownerId', '==', userId));
+    }
+    else if (scope === 'team' && teamId) {
+        scopeQuery = query(filesRef, where('scope', '==', 'team'), where('teamId', '==', teamId));
+    }
+    else {
+        return { action: 'not-found' };
+    }
+    const snap = await getDocs(scopeQuery);
+    const prefix = docPath + '/';
+    // Use an array as a single-slot holder rather than `let`. Inside the
+    // forEach callback TS can't see same-scope assignment to a `let`
+    // (the closure breaks control-flow analysis), so the variable type
+    // would stay `null` post-loop. The array sidesteps that.
+    const folderHolder = [];
+    const descendants = [];
+    snap.forEach((d) => {
+        const data = d.data();
+        const p = data['path'];
+        if (typeof p !== 'string' || !p)
+            return;
+        if (data['type'] === 'folder' && p === docPath) {
+            folderHolder[0] = { id: d.id, ref: d.ref, data };
         }
-      }
-    }
-    await deleteDoc(ref);
-  }
-
-  if (folderDocSnap) {
-    await deleteDoc(folderDocSnap.ref);
-  }
-
-  return {
-    action: 'deleted',
-    folderId: folderDocSnap ? folderDocSnap.id : null,
-    childCount: descendants.length,
-  };
+        else if (p.startsWith(prefix)) {
+            descendants.push({ id: d.id, ref: d.ref, data });
+        }
+    });
+    const folderDocSnap = folderHolder[0] ?? null;
+    if (!folderDocSnap && descendants.length === 0) {
+        return { action: 'not-found' };
+    }
+    // Delete each descendant's blob (files only) then its doc.
+    for (const { id, ref, data } of descendants) {
+        if (data['type'] !== 'folder') {
+            const ext = extFromPath(typeof data['path'] === 'string' ? data['path'] : '');
+            // Re-check the doc still exists right before calling the
+            // Storage SDK. If a concurrent caller (chokidar's per-file
+            // unlink fan-out, or another cascade) already deleted the
+            // metadata doc, the Storage rule's cross-service
+            // firestore.get(...).data.scope reads null and throws "Null
+            // value error", and the Storage SDK retries for several
+            // seconds before surfacing storage/unauthorized. The retry
+            // latency is what blew the test budget on DOU-242 + DOU-251.
+            // Skipping the SDK call avoids both the rule throw and the
+            // retry; the orphan blob (if any) is cleaned up by the
+            // data-integrity audit (DOU-244).
+            const recheck = await getDoc(ref);
+            if (recheck.exists()) {
+                try {
+                    await deleteBlob({ storage, orgId, fileId: id, ext });
+                }
+                catch {
+                    // Orphan blob is a soft failure; the doc delete is the
+                    // load-bearing state transition for the user's view.
+                }
+            }
+        }
+        await deleteDoc(ref);
+    }
+    if (folderDocSnap) {
+        await deleteDoc(folderDocSnap.ref);
+    }
+    return {
+        action: 'deleted',
+        folderId: folderDocSnap ? folderDocSnap.id : null,
+        childCount: descendants.length,
+    };
 }
-
 // ---- 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
@@ -360,134 +312,126 @@ export async function deleteFolderFromCloud({
  *   { 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(),
-  localModifiedAt = null,
-}) {
-  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) {
-    // Deterministic id by {scope, teamId, ownerId, path}; concurrent
-    // sibling creates for the same path collapse onto the same doc
-    // instead of producing duplicates. Mirrors the DOU-240 folder fix.
-    const fileId = fileDocId({
-      scope,
-      teamId: scope === 'team' ? (teamId || null) : null,
-      ownerId: scope === 'private' ? userId : null,
-      path: docPath,
+export async function pushFileToCloud({ filesRef, storage, orgId, userId, scope, teamId, docPath, data, mimeType, now = new Date().toISOString(), localModifiedAt = null, }) {
+    if (scope === 'shared-with-me' || scope === 'shared-by-me') {
+        return { action: 'skipped', reason: 'shared-scope' };
+    }
+    let snapshot;
+    if (scope === 'private') {
+        if (!userId) {
+            throw new Error('pushFileToCloud: userId is required for private scope');
+        }
+        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) {
+        // Deterministic id by {scope, teamId, ownerId, path}; concurrent
+        // sibling creates for the same path collapse onto the same doc
+        // instead of producing duplicates. Mirrors the DOU-240 folder fix.
+        const fileId = fileDocId({
+            scope,
+            teamId: scope === 'team' ? (teamId || null) : null,
+            ownerId: scope === 'private' ? userId : null,
+            path: docPath,
+        });
+        const newDocRef = doc(filesRef, fileId);
+        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];
+    if (!docSnap) {
+        // Defensive: snapshot.empty was false but docs[0] is undefined.
+        // Shouldn't happen with Firestore, but keep the type narrowed.
+        throw new Error('pushFileToCloud: snapshot.docs[0] missing despite non-empty snapshot');
+    }
+    const existing = docSnap.data();
+    const existingParentId = existing['parentId'] == null ? null : existing['parentId'];
+    if (existing['contentHash'] === contentHash
+        && existing['type'] === 'file'
+        && existing['name'] === fileName
+        && existingParentId === parentId) {
+        return { action: 'noop', fileId: docSnap.id };
+    }
+    // Last-write-wins: never let an older local file overwrite a newer
+    // server edit. The caller (sync daemon) passes the local file's mtime;
+    // if the server doc was updated more recently, leave it for the
+    // firestore -> local pull to bring down instead.
+    const existingUpdatedAt = existing['updatedAt'];
+    if (localModifiedAt
+        && typeof existingUpdatedAt === 'string'
+        && existingUpdatedAt > localModifiedAt) {
+        return { action: 'skipped-stale', fileId: docSnap.id };
+    }
+    const existingMime = typeof existing['mimeType'] === 'string' ? existing['mimeType'] : undefined;
+    const resolvedMime = mimeType || existingMime || 'text/markdown';
+    await updateDoc(docSnap.ref, {
+        type: 'file',
+        name: fileName,
+        parentId,
+        updatedAt: now,
+        storagePath: storagePathFor(orgId, docSnap.id, ext),
+        contentHash,
+        size,
+        mimeType: resolvedMime,
     });
-    const newDocRef = doc(filesRef, fileId);
-    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 };
-  }
-  // Last-write-wins: never let an older local file overwrite a newer
-  // server edit. The caller (sync daemon) passes the local file's mtime;
-  // if the server doc was updated more recently, leave it for the
-  // firestore -> local pull to bring down instead.
-  if (localModifiedAt && existing.updatedAt && existing.updatedAt > localModifiedAt) {
-    return { action: 'skipped-stale', 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 };
+        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.
  *
@@ -498,92 +442,83 @@ export async function pushFileToCloud({
  *
  * 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.
-  //
-  // Race tolerance (DOU-242 / DOU-252): a concurrent delete can remove
-  // the metadata doc between our snapshot read and our blob-delete
-  // (most commonly the cascade in deleteFolderFromCloud firing first
-  // for a path chokidar's per-file `unlink` event then re-tries via
-  // this function). Pre-check the doc still exists right before the
-  // Storage SDK call: if it's gone, skip the blob delete entirely.
-  // This avoids the Storage rule's cross-service firestore.get(...)
-  // reading null and throwing "Null value error", and avoids the
-  // Storage SDK's multi-second retry chain that breaks test budgets.
-  const preRecheck = await getDoc(docSnap.ref);
-  if (!preRecheck.exists()) {
-    return { action: 'not-found', fileId };
-  }
-  try {
-    await deleteBlob({ storage, orgId, fileId, ext });
-  } catch (err) {
-    const code = err && err.code;
-    if (code === 'storage/unauthorized') {
-      // Last-resort safety net for the narrow window between
-      // preRecheck above and the SDK actually firing. Treat as
-      // already-deleted if the doc is now gone.
-      const recheck = await getDoc(docSnap.ref);
-      if (!recheck.exists()) {
-        return { action: 'not-found', fileId };
-      }
-    }
-    throw err;
-  }
-  // Concurrent-delete tolerance (DOU-242): the Firestore delete rule
-  // evaluates canAccessFile() which reads resource.data; if another
-  // caller already deleted this doc, resource is null and the rule
-  // throws "Null value error" → SDK surfaces permission-denied. The
-  // desired end state (no doc) is already achieved, so treat as
-  // already-deleted instead of propagating.
-  try {
-    await deleteDoc(docSnap.ref);
-  } catch (err) {
-    const code = err && err.code;
-    if (code === 'permission-denied') {
-      const recheck = await getDoc(docSnap.ref);
-      if (!recheck.exists()) {
+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') {
+        if (!userId) {
+            throw new Error('deleteFileFromCloud: userId is required for private scope');
+        }
+        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];
+    if (!docSnap) {
+        return { action: 'not-found' };
+    }
+    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.
+    //
+    // Race tolerance (DOU-242 / DOU-252): a concurrent delete can remove
+    // the metadata doc between our snapshot read and our blob-delete
+    // (most commonly the cascade in deleteFolderFromCloud firing first
+    // for a path chokidar's per-file `unlink` event then re-tries via
+    // this function). Pre-check the doc still exists right before the
+    // Storage SDK call: if it's gone, skip the blob delete entirely.
+    // This avoids the Storage rule's cross-service firestore.get(...)
+    // reading null and throwing "Null value error", and avoids the
+    // Storage SDK's multi-second retry chain that breaks test budgets.
+    const preRecheck = await getDoc(docSnap.ref);
+    if (!preRecheck.exists()) {
         return { action: 'not-found', fileId };
-      }
     }
-    throw err;
-  }
-  return { action: 'deleted', fileId };
+    try {
+        await deleteBlob({ storage, orgId, fileId, ext });
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === 'storage/unauthorized') {
+            // Last-resort safety net for the narrow window between
+            // preRecheck above and the SDK actually firing. Treat as
+            // already-deleted if the doc is now gone.
+            const recheck = await getDoc(docSnap.ref);
+            if (!recheck.exists()) {
+                return { action: 'not-found', fileId };
+            }
+        }
+        throw err;
+    }
+    // Concurrent-delete tolerance (DOU-242): the Firestore delete rule
+    // evaluates canAccessFile() which reads resource.data; if another
+    // caller already deleted this doc, resource is null and the rule
+    // throws "Null value error" → SDK surfaces permission-denied. The
+    // desired end state (no doc) is already achieved, so treat as
+    // already-deleted instead of propagating.
+    try {
+        await deleteDoc(docSnap.ref);
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === 'permission-denied') {
+            const recheck = await getDoc(docSnap.ref);
+            if (!recheck.exists()) {
+                return { action: 'not-found', fileId };
+            }
+        }
+        throw err;
+    }
+    return { action: 'deleted', fileId };
 }
+//# sourceMappingURL=files.js.map