@doubling/compound-sync 1.12.3 → 1.12.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doubling/compound-sync",
-  "version": "1.12.3",
+  "version": "1.12.5",
   "description": "Bidirectional sync between Compound and local markdown files",
   "type": "module",
   "bin": {
@@ -8,22 +8,41 @@
   },
   "files": [
     "sync.js",
+    "sync.d.ts",
     "org-sync.js",
+    "org-sync.d.ts",
     "sync-state.js",
+    "sync-state.d.ts",
+    "manifest.js",
+    "manifest.d.ts",
+    "push-outcome.js",
+    "push-outcome.d.ts",
     "config.js",
+    "config.d.ts",
     "paths.js",
     "paths.d.ts",
     "files.js",
+    "files.d.ts",
     "folder-chain.js",
+    "folder-chain.d.ts",
     "storage-helpers.js",
+    "storage-helpers.d.ts",
     "team-registry.js",
+    "team-registry.d.ts",
     "auth-persistence.js",
+    "auth-persistence.d.ts",
     "pre-mint-app-check.js",
+    "pre-mint-app-check.d.ts",
     "setup-auth-with-pre-mint.js",
+    "setup-auth-with-pre-mint.d.ts",
     "yjs-firestore-update-store.js",
+    "yjs-firestore-update-store.d.ts",
     "yjs-provider.js",
+    "yjs-provider.d.ts",
     "yjs-file-binding.js",
+    "yjs-file-binding.d.ts",
     "yjs-binding-state.js",
+    "yjs-binding-state.d.ts",
     "README.md"
   ],
   "scripts": {
@@ -31,12 +50,13 @@
     "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 files-helpers.test.js",
-    "test:integration": "node --import tsx --test --test-timeout=180000 files-push-create-private.test.js files-push-create-team.test.js files-push-update-private.test.js files-push-binary.test.js files-push-staleness.test.js files-push-storage-fail.test.js files-push-no-content.test.js files-push-stamps.test.js files-push-folder.test.js files-delete.test.js files-delete-folder.test.js files-read-blob.test.js org-sync-local-edit.test.js org-sync-file-ops.test.js org-sync-mtime.test.js org-sync-rename.test.js org-sync-yjs-pull.test.js org-sync-yjs-push.test.js org-sync-cold-start.test.js org-sync-special-chars.test.js org-sync-copy.test.js two-user-happy-paths.test.js two-user-yjs-convergence.test.js files-concurrency-folder-create.test.js files-concurrency-file-create.test.js files-concurrency-file-delete.test.js files-concurrency-folder-delete.test.js",
+    "test:unit": "node --import tsx --test config.test.js paths.test.js storage-helpers.test.ts folder-chain.test.ts team-registry.test.ts auth-persistence.test.js pre-mint-app-check.test.js setup-auth-with-pre-mint.test.js sync-state.test.ts manifest.test.ts push-outcome.test.ts yjs-file-binding.test.ts yjs-binding-state.test.ts files-helpers.test.js",
+    "test:integration": "node --import tsx --test --test-timeout=180000 files-push-create-private.test.js files-push-create-team.test.js files-push-update-private.test.js files-push-binary.test.js files-push-staleness.test.js files-push-storage-fail.test.js files-push-no-content.test.js files-push-stamps.test.js files-push-folder.test.js files-delete.test.js files-delete-folder.test.js files-read-blob.test.js org-sync-local-edit.test.js org-sync-file-ops.test.js org-sync-mtime.test.js org-sync-rename.test.js org-sync-yjs-pull.test.js org-sync-yjs-push.test.js org-sync-cold-start.test.js org-sync-startup-ordering.test.js org-sync-manifest-reconcile.test.js org-sync-special-chars.test.js org-sync-copy.test.js two-user-happy-paths.test.js two-user-yjs-convergence.test.js files-concurrency-folder-create.test.js files-concurrency-file-create.test.js files-concurrency-file-delete.test.js files-concurrency-folder-delete.test.js",
     "test:integration:emulator": "USE_EMULATOR=true firebase emulators:exec --only firestore,storage,auth 'npm run test:integration'",
     "test": "npm run test:unit && npm run test:integration"
   },
   "dependencies": {
+    "@doubling/types": "*",
     "chokidar": "^5.0.0",
     "fast-diff": "^1.3.0",
     "firebase": "^12.14.0",
@@ -51,5 +71,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
   }
 }

package/paths.d.ts

@@ -4,7 +4,7 @@ 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;
+    teamId?: string | undefined;
     docPath: string;
 }
 export declare function teamFolderName(teamName: string): string;

package/pre-mint-app-check.d.ts

@@ -0,0 +1,6 @@
+export interface ExchangeDeps {
+    fetch?: typeof globalThis.fetch;
+}
+export declare function readPersistedRefreshToken(filePath: string): string | null;
+export declare function exchangeRefreshTokenForIdToken(refreshToken: string, apiKey: string, deps?: ExchangeDeps): Promise<string>;
+//# sourceMappingURL=pre-mint-app-check.d.ts.map

package/pre-mint-app-check.js

@@ -18,9 +18,7 @@
 // an App Check token from our mintappchecktoken cloud function, and
 // initializeAppCheck. Now the SDK's :lookup carries the App Check
 // header and silent restore succeeds.
-
 import fs from 'node:fs';
-
 // Read the refresh token stored by Firebase Auth's file persistence.
 // The persistence stores a single key per app:
 //   'firebase:authUser:<apiKey>:[DEFAULT]'  →  { uid, ..., stsTokenManager: { refreshToken, ... } }
@@ -29,28 +27,33 @@ import fs from 'node:fs';
 // entry, and pull its refresh token. Returns null when there's nothing
 // usable (file missing, corrupt, empty, or no refresh token field).
 export function readPersistedRefreshToken(filePath) {
-  let raw;
-  try {
-    raw = fs.readFileSync(filePath, 'utf8');
-  } catch {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let store;
+    try {
+        store = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!store || typeof store !== 'object')
+        return null;
+    const s = store;
+    for (const key of Object.keys(s)) {
+        if (!key.startsWith('firebase:authUser:'))
+            continue;
+        const user = s[key];
+        const rt = user?.stsTokenManager?.refreshToken;
+        if (typeof rt === 'string' && rt.length > 0)
+            return rt;
+    }
     return null;
-  }
-  let store;
-  try {
-    store = JSON.parse(raw);
-  } catch {
-    return null;
-  }
-  if (!store || typeof store !== 'object') return null;
-  for (const key of Object.keys(store)) {
-    if (!key.startsWith('firebase:authUser:')) continue;
-    const user = store[key];
-    const rt = user?.stsTokenManager?.refreshToken;
-    if (typeof rt === 'string' && rt.length > 0) return rt;
-  }
-  return null;
 }
-
 // Exchange a Firebase refresh token for a fresh ID token via Google's
 // secure token endpoint. This endpoint lives at securetoken.googleapis.com
 // and is intentionally NOT under App Check enforcement (App Check
@@ -64,21 +67,25 @@ export function readPersistedRefreshToken(filePath) {
 //
 // `deps.fetch` is injectable for tests; defaults to the global fetch.
 export async function exchangeRefreshTokenForIdToken(refreshToken, apiKey, deps = {}) {
-  const f = deps.fetch || fetch;
-  const url = `https://securetoken.googleapis.com/v1/token?key=${apiKey}`;
-  const body = new URLSearchParams({
-    grant_type: 'refresh_token',
-    refresh_token: refreshToken,
-  }).toString();
-  const resp = await f(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-    body,
-  });
-  if (!resp.ok) {
-    const errBody = await resp.text().catch(() => '');
-    throw new Error(`secure-token exchange failed (${resp.status}): ${errBody}`);
-  }
-  const json = await resp.json();
-  return json.id_token;
+    const f = deps.fetch || fetch;
+    const url = `https://securetoken.googleapis.com/v1/token?key=${apiKey}`;
+    const body = new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+    }).toString();
+    const resp = await f(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body,
+    });
+    if (!resp.ok) {
+        const errBody = await resp.text().catch(() => '');
+        throw new Error(`secure-token exchange failed (${resp.status}): ${errBody}`);
+    }
+    const json = await resp.json();
+    if (typeof json.id_token !== 'string' || !json.id_token) {
+        throw new Error('secure-token exchange returned no id_token');
+    }
+    return json.id_token;
 }
+//# sourceMappingURL=pre-mint-app-check.js.map

package/push-outcome.d.ts

@@ -0,0 +1,9 @@
+export interface PushFileOutcome {
+    action: string;
+    storageError?: unknown;
+    fileId?: string;
+    reason?: string;
+    fileData?: unknown;
+}
+export declare function shouldPersistLocalSyncState(result: PushFileOutcome): boolean;
+//# sourceMappingURL=push-outcome.d.ts.map

package/push-outcome.js

@@ -0,0 +1,11 @@
+// Whether a pushFileToCloud result should update local sync artifacts
+// (content baseline + manifest). Partial uploads (Firestore OK, blob
+// failed) must not be recorded as successfully synced.
+export function shouldPersistLocalSyncState(result) {
+    if (result.storageError)
+        return false;
+    return result.action === 'created'
+        || result.action === 'updated'
+        || result.action === 'noop';
+}
+//# sourceMappingURL=push-outcome.js.map

package/setup-auth-with-pre-mint.d.ts

@@ -0,0 +1,24 @@
+import type { FirebaseApp } from 'firebase/app';
+import { type Auth, type Dependencies } from 'firebase/auth';
+import type { FilePersistenceClass } from './auth-persistence.js';
+export interface SetupAuthInput {
+    app: FirebaseApp;
+    authFilePath: string;
+    apiKey: string;
+    appCheckUrl?: string | null | undefined;
+}
+export type InitializeAuthFn = (app: FirebaseApp, deps?: Dependencies) => Auth;
+export interface SetupAuthDeps {
+    readPersistedRefreshToken: (authFilePath: string) => string | null;
+    exchangeRefreshTokenForIdToken: (refreshToken: string, apiKey: string) => Promise<string>;
+    initAppCheckWithIdToken: (app: FirebaseApp, appCheckUrl: string, idToken: string) => Promise<unknown>;
+    makeFilePersistence: (filePath: string) => FilePersistenceClass;
+    initializeAuth: InitializeAuthFn;
+}
+export interface SetupAuthResult {
+    auth: Auth;
+    persistence: FilePersistenceClass;
+    appCheckPreMinted: boolean;
+}
+export declare function setupAuthWithPreMint({ app, authFilePath, apiKey, appCheckUrl }: SetupAuthInput, deps: SetupAuthDeps): Promise<SetupAuthResult>;
+//# sourceMappingURL=setup-auth-with-pre-mint.d.ts.map

package/setup-auth-with-pre-mint.js

@@ -25,60 +25,53 @@
 // real network calls. sync.js wires the real deps in two places (the
 // discover path and the main daemon path), eliminating the duplicated
 // inline pre-mint blocks that previously lived in sync.js.
-
-export async function setupAuthWithPreMint(
-  { app, authFilePath, apiKey, appCheckUrl },
-  deps,
-) {
-  const {
-    readPersistedRefreshToken,
-    exchangeRefreshTokenForIdToken,
-    initAppCheckWithIdToken,
-    makeFilePersistence,
-    initializeAuth,
-  } = deps;
-
-  // 1. Read the persisted refresh token directly, before involving the
-  //    Firebase Auth SDK. If there's nothing persisted (first launch),
-  //    this returns null and we skip pre-mint; the caller's
-  //    browser-auth path handles first-run sign-in.
-  const refreshToken = readPersistedRefreshToken(authFilePath);
-
-  // 2. Pre-mint App Check on the app, if we have what we need. This
-  //    MUST complete before step 3 (initializeAuth), or the SDK's
-  //    startup :lookup races our pre-mint and goes out unauthed.
-  let appCheckPreMinted = false;
-  if (refreshToken && appCheckUrl) {
-    try {
-      const idToken = await exchangeRefreshTokenForIdToken(refreshToken, apiKey);
-      await initAppCheckWithIdToken(app, appCheckUrl, idToken);
-      appCheckPreMinted = true;
-    } catch (err) {
-      // Refresh token revoked, network blip, or App Check function
-      // error: don't block startup. The Auth SDK's :lookup will still
-      // fail under enforcement (and the SDK will null-out currentUser),
-      // and the caller's browser-auth path will take over. The
-      // persistence freeze guard keeps the on-disk file intact.
-      console.log(`Pre-mint App Check failed (falling back to browser): ${err.message}`);
+import { initializeAuth as _firebaseInitializeAuth } from 'firebase/auth';
+// Compile-time check that `initializeAuth` from firebase/auth still
+// matches the dep shape we declared. If Firebase changes the
+// signature, this assignment fails and the diff makes it obvious.
+const _initializeAuthShapeCheck = _firebaseInitializeAuth;
+void _initializeAuthShapeCheck;
+export async function setupAuthWithPreMint({ app, authFilePath, apiKey, appCheckUrl }, deps) {
+    const { readPersistedRefreshToken, exchangeRefreshTokenForIdToken, initAppCheckWithIdToken, makeFilePersistence, initializeAuth, } = deps;
+    // 1. Read the persisted refresh token directly, before involving the
+    //    Firebase Auth SDK. If there's nothing persisted (first launch),
+    //    this returns null and we skip pre-mint; the caller's
+    //    browser-auth path handles first-run sign-in.
+    const refreshToken = readPersistedRefreshToken(authFilePath);
+    // 2. Pre-mint App Check on the app, if we have what we need. This
+    //    MUST complete before step 3 (initializeAuth), or the SDK's
+    //    startup :lookup races our pre-mint and goes out unauthed.
+    let appCheckPreMinted = false;
+    if (refreshToken && appCheckUrl) {
+        try {
+            const idToken = await exchangeRefreshTokenForIdToken(refreshToken, apiKey);
+            await initAppCheckWithIdToken(app, appCheckUrl, idToken);
+            appCheckPreMinted = true;
+        }
+        catch (err) {
+            // Refresh token revoked, network blip, or App Check function
+            // error: don't block startup. The Auth SDK's :lookup will still
+            // fail under enforcement (and the SDK will null-out currentUser),
+            // and the caller's browser-auth path will take over. The
+            // persistence freeze guard keeps the on-disk file intact.
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(`Pre-mint App Check failed (falling back to browser): ${msg}`);
+        }
     }
-  }
-
-  // 3. Now initializeAuth. App Check (if it was pre-minted) is already
-  //    registered on the app, so the SDK's :lookup carries the header.
-  //    makeFilePersistence returns a CLASS (Firebase's persistence
-  //    contract is `new Persistence()`), and the unfreeze method is a
-  //    static on that class — we call it as PersistenceClass.unfreeze().
-  const PersistenceClass = makeFilePersistence(authFilePath);
-  const auth = initializeAuth(app, { persistence: PersistenceClass });
-
-  // 4. Wait for the SDK to finish its startup validation. If we
-  //    pre-minted successfully and the refresh token is still valid,
-  //    auth.currentUser will be the restored user.
-  await auth.authStateReady();
-
-  // 5. Unfreeze persistence so post-init _remove calls (e.g., an
-  //    explicit sign-out by the user) actually clear the file.
-  PersistenceClass.unfreeze();
-
-  return { auth, persistence: PersistenceClass, appCheckPreMinted };
+    // 3. Now initializeAuth. App Check (if it was pre-minted) is already
+    //    registered on the app, so the SDK's :lookup carries the header.
+    //    makeFilePersistence returns a CLASS (Firebase's persistence
+    //    contract is `new Persistence()`), and the unfreeze method is a
+    //    static on that class — we call it as PersistenceClass.unfreeze().
+    const PersistenceClass = makeFilePersistence(authFilePath);
+    const auth = initializeAuth(app, { persistence: PersistenceClass });
+    // 4. Wait for the SDK to finish its startup validation. If we
+    //    pre-minted successfully and the refresh token is still valid,
+    //    auth.currentUser will be the restored user.
+    await auth.authStateReady();
+    // 5. Unfreeze persistence so post-init _remove calls (e.g., an
+    //    explicit sign-out by the user) actually clear the file.
+    PersistenceClass.unfreeze();
+    return { auth, persistence: PersistenceClass, appCheckPreMinted };
 }
+//# sourceMappingURL=setup-auth-with-pre-mint.js.map

package/storage-helpers.d.ts

@@ -0,0 +1,14 @@
+export { EXT_TO_MIME, mimeTypeFromExt, isTextMimeType, extFromPath, storagePathFor, } from '@doubling/types';
+export type StorageData = string | Buffer | Uint8Array | ArrayBuffer | null | undefined;
+export declare function contentByteSize(data: StorageData): number;
+export declare function toBytes(data: StorageData): Buffer;
+export declare function computeContentHash(data: StorageData): string;
+export interface DocIdInput {
+    scope: string;
+    teamId?: string | null;
+    ownerId?: string | null;
+    path: string;
+}
+export declare function folderDocId({ scope, teamId, ownerId, path }: DocIdInput): string;
+export declare function fileDocId({ scope, teamId, ownerId, path }: DocIdInput): string;
+//# sourceMappingURL=storage-helpers.d.ts.map

package/storage-helpers.js

@@ -1,50 +1,55 @@
-// Pure Node-side storage helpers. No Firebase imports.
+// Node-side storage helpers (sync daemon environment).
 //
-// 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.
+// The pure, environment-agnostic parts (`EXT_TO_MIME`,
+// `mimeTypeFromExt`, `isTextMimeType`, `extFromPath`,
+// `storagePathFor`) live in `@doubling/types` and are re-exported
+// here so existing imports continue to work. Adding a new extension
+// is now a single edit in `@doubling/types`'s `mime.ts` (DOU-182).
 //
-// 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'}`;
-}
-
+// The node-specific bytes / hash helpers (`toBytes`,
+// `contentByteSize`, `computeContentHash`) and the deterministic
+// doc-id helpers (`folderDocId`, `fileDocId`, DOU-240) stay here
+// because they rely on `Buffer` and `crypto.createHash`, which the
+// web client implements differently. A future Phase 5 cleanup could
+// move to an isomorphic Web Crypto implementation.
+import crypto from 'node:crypto';
+export { EXT_TO_MIME, mimeTypeFromExt, isTextMimeType, extFromPath, storagePathFor, } from '@doubling/types';
 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');
+    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 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');
 }
-
 export function computeContentHash(data) {
-  const buf = toBytes(data);
-  return crypto.createHash('sha256').update(buf).digest('hex');
+    const buf = toBytes(data);
+    return crypto.createHash('sha256').update(buf).digest('hex');
 }
-
 // Deterministic Firestore document id for a folder doc identified by
 // scope + ownership + path. Two concurrent creates collapse onto the
 // same id, so a setDoc by all of them is idempotent (no duplicates).
 // See DOU-240 for the race this prevents.
 export function folderDocId({ scope, teamId, ownerId, path }) {
-  const key = `folder|${scope}|${teamId ?? ''}|${ownerId ?? ''}|${path}`;
-  return 'f-' + crypto.createHash('sha256').update(key).digest('hex').slice(0, 20);
+    const key = `folder|${scope}|${teamId ?? ''}|${ownerId ?? ''}|${path}`;
+    return 'f-' + crypto.createHash('sha256').update(key).digest('hex').slice(0, 20);
 }
-
 // Deterministic Firestore document id for a file doc identified by
 // scope + ownership + path. Same purpose as folderDocId: concurrent
 // creates at the same path collapse onto one doc.
@@ -56,76 +61,7 @@ export function folderDocId({ scope, teamId, ownerId, path }) {
 // reuse of a path (e.g., delete then recreate) is fine because the
 // old doc was already removed by unlink before the new add fires.
 export function fileDocId({ scope, teamId, ownerId, path }) {
-  const key = `file|${scope}|${teamId ?? ''}|${ownerId ?? ''}|${path}`;
-  return 'x-' + crypto.createHash('sha256').update(key).digest('hex').slice(0, 20);
-}
-
-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',
-  // Obsidian Bases (.base) files are YAML. Mapping to text/yaml here
-  // (in addition to the web copy) ensures the daemon uploads .base as
-  // a UTF-8 text blob with the right Content-Type so the web client's
-  // eager-load path picks up entity.content for the Bases renderer.
-  base: 'text/yaml',
-  yaml: 'text/yaml',
-  yml: 'text/yaml',
-  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',
-  heic: 'image/heic',
-  heif: 'image/heif',
-  mp3: 'audio/mpeg',
-  wav: 'audio/wav',
-  mp4: 'video/mp4',
-  webm: 'video/webm',
-  mov: 'video/quicktime',
-  zip: 'application/zip',
-  // Office Open XML (modern Office). The full type strings are
-  // mandatory: tools that dispatch by mime (Excel, third-party readers)
-  // ignore alternative spellings.
-  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-  // Legacy Office formats (pre-2007 binary containers).
-  xls: 'application/vnd.ms-excel',
-  doc: 'application/msword',
-  ppt: 'application/vnd.ms-powerpoint',
-};
-
-export function mimeTypeFromExt(ext) {
-  if (ext == null) return 'application/octet-stream';
-  return EXT_TO_MIME[String(ext).toLowerCase()] || 'application/octet-stream';
+    const key = `file|${scope}|${teamId ?? ''}|${ownerId ?? ''}|${path}`;
+    return 'x-' + crypto.createHash('sha256').update(key).digest('hex').slice(0, 20);
 }
+//# sourceMappingURL=storage-helpers.js.map

package/sync-state.d.ts

@@ -0,0 +1,4 @@
+export type SyncState = Record<string, string>;
+export declare function loadSyncState(filePath: string): SyncState;
+export declare function saveSyncState(filePath: string, state: SyncState): void;
+//# sourceMappingURL=sync-state.d.ts.map

package/sync-state.js

@@ -6,27 +6,41 @@
 // in-memory baseline alone is empty on a cold start, which forced an
 // unreliable mtime fallback). Small JSON file; best-effort writes (a
 // failed write must never take down sync).
-
 import fs from 'node:fs';
 import path from 'node:path';
-
 // Load the baseline map ({ trackingKey: contentHash }). Missing or
 // corrupt file reads as {} so a first run / damaged state can't crash.
+// Validates that every entry is a string; non-string entries (from a
+// partial write or hand-edit) are dropped silently rather than leaking
+// invalid shapes into runtime.
 export function loadSyncState(filePath) {
-  try {
-    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    return parsed && typeof parsed === 'object' ? parsed : {};
-  } catch {
-    return {};
-  }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return {};
+        const result = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (typeof value === 'string') {
+                result[key] = value;
+            }
+            else {
+                console.error(`[sync-state] dropped invalid entry for ${key}`);
+            }
+        }
+        return result;
+    }
+    catch {
+        return {};
+    }
 }
-
 export function saveSyncState(filePath, state) {
-  try {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(state));
-  } catch {
-    // Best-effort: losing the baseline only costs us a cold-start
-    // reconciliation next launch, never data.
-  }
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(state));
+    }
+    catch {
+        // Best-effort: losing the baseline only costs us a cold-start
+        // reconciliation next launch, never data.
+    }
 }
+//# sourceMappingURL=sync-state.js.map

package/sync.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * Bidirectional sync between Firestore files and local markdown files.
+ * Uses Firebase client SDK with browser-based auth — no gcloud needed.
+ *
+ * Local folder structure:
+ *   {SyncFolder}/
+ *     {TeamName} Teamspace/   ← team files (bidirectional)
+ *     Private/                ← user's private files (bidirectional)
+ *     Shared by Me/           ← symlinks to files you've shared
+ *     Shared with Me/         ← files shared with you (read-only)
+ *
+ * Usage: node sync.js [--config <file>] [--setup] [--env <name>]
+ *        node sync.js --version
+ *        node sync.js --help
+ */
+export {};
+//# sourceMappingURL=sync.d.ts.map