@doubling/compound-sync 1.12.4 → 1.12.5

package/team-registry.d.ts

@@ -0,0 +1,41 @@
+export interface TeamData {
+    name?: string;
+    [key: string]: unknown;
+}
+export type TeamCallback = (teamId: string, teamData: TeamData) => void;
+export interface TeamRegistryOptions {
+    onSetup: TeamCallback;
+    onTeardown: TeamCallback;
+}
+export type TeamDocChange = {
+    type: 'added';
+    id: string;
+    data: TeamData;
+} | {
+    type: 'modified';
+    id: string;
+    data: TeamData;
+} | {
+    type: 'removed';
+    id: string;
+};
+export declare class TeamRegistry {
+    private readonly teams;
+    private readonly teamIdsByName;
+    private readonly onSetup;
+    private readonly onTeardown;
+    constructor({ onSetup, onTeardown }: TeamRegistryOptions);
+    bootstrap(teamId: string, teamData: TeamData): boolean;
+    add(teamId: string, teamData: TeamData): boolean;
+    modify(teamId: string, teamData: TeamData): boolean;
+    remove(teamId: string): boolean;
+    applyChange(change: TeamDocChange): boolean;
+    has(teamId: string): boolean;
+    get(teamId: string): TeamData | undefined;
+    getIdByName(teamName: string): string | undefined;
+    size(): number;
+    entries(): IterableIterator<[string, TeamData]>;
+    names(): string[];
+    teamIdsByNameMap(): Map<string, string>;
+}
+//# sourceMappingURL=team-registry.d.ts.map

package/team-registry.js

@@ -17,90 +17,99 @@
 //   });
 //   // 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;
-  }
-
-  // Register a team in-memory without wiring listeners. Used during
-  // startup so manifest reconcile can resolve team-scoped paths before
-  // any file onSnapshot handlers run (DOU-55 ordering).
-  bootstrap(teamId, teamData) {
-    if (this.teams.has(teamId)) return false;
-    this.teams.set(teamId, teamData);
-    if (teamData && teamData.name) {
-      this.teamIdsByName.set(teamData.name, teamId);
+    teams = new Map();
+    teamIdsByName = new Map();
+    onSetup;
+    onTeardown;
+    constructor({ onSetup, onTeardown }) {
+        this.onSetup = onSetup;
+        this.onTeardown = onTeardown;
     }
-    return true;
-  }
-
-  // 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);
+    // Register a team in-memory without wiring listeners. Used during
+    // startup so manifest reconcile can resolve team-scoped paths before
+    // any file onSnapshot handlers run (DOU-55 ordering).
+    bootstrap(teamId, teamData) {
+        if (this.teams.has(teamId))
+            return false;
+        this.teams.set(teamId, teamData);
+        if (teamData && teamData.name) {
+            this.teamIdsByName.set(teamData.name, teamId);
+        }
+        return true;
     }
-    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);
+    // 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;
     }
-    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);
+    // 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;
     }
-    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); }
+    // 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(change) {
+        if (change.type === 'added')
+            return this.add(change.id, change.data);
+        if (change.type === 'modified')
+            return this.modify(change.id, change.data);
+        return this.remove(change.id);
+    }
+    // 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((n) => Boolean(n));
+    }
+    // The team-name -> team-id map the daemon hands to scopeFromLocalPath
+    // (which takes a Map<teamName, teamId> for routing local paths back
+    // to their owning team). Exposed as the live map, not a copy, so
+    // updates propagate without a re-publish step.
+    teamIdsByNameMap() { return this.teamIdsByName; }
 }
+//# sourceMappingURL=team-registry.js.map

package/yjs-binding-state.d.ts

@@ -0,0 +1,4 @@
+export declare function loadBindingState(localPath: string, fileId: string): Uint8Array | null;
+export declare function saveBindingState(localPath: string, fileId: string, encoded: Uint8Array): void;
+export declare function deleteBindingState(localPath: string, fileId: string): void;
+//# sourceMappingURL=yjs-binding-state.d.ts.map

package/yjs-binding-state.js

@@ -15,47 +15,50 @@
 // `<localPath>/.compound-yjs-binding/<fileId>.yjs`. The binary blob is
 // the output of Y.encodeStateAsUpdate(doc); the daemon applies it via
 // Y.applyUpdate(doc, blob) on restore.
-
 import fs from 'node:fs';
 import path from 'node:path';
-
 const STATE_DIR = '.compound-yjs-binding';
-
 function statePathFor(localPath, fileId) {
-  return path.join(localPath, STATE_DIR, `${fileId}.yjs`);
+    return path.join(localPath, STATE_DIR, `${fileId}.yjs`);
 }
-
 // Load the encoded Y.Doc state for a file. Returns null if no state
 // exists yet (first run, or this fileId hasn't been synced before) or
 // if the file is unreadable for any reason (corruption, permissions).
 // Treating unreadable as "no state" is safe: the binding falls back to
 // its first-run behavior, which writes ytext to disk on initial flush.
 export function loadBindingState(localPath, fileId) {
-  try {
-    return fs.readFileSync(statePathFor(localPath, fileId));
-  } catch {
-    return null;
-  }
+    try {
+        return fs.readFileSync(statePathFor(localPath, fileId));
+    }
+    catch {
+        return null;
+    }
 }
-
 // Persist the encoded Y.Doc state for a file. Atomic via write-to-tmp +
 // rename so a crash mid-write can't leave a half-written .yjs file that
 // would corrupt the next startup. Best-effort: a failed save costs us a
 // cold-start reconciliation next launch, never data.
 export function saveBindingState(localPath, fileId, encoded) {
-  const finalPath = statePathFor(localPath, fileId);
-  const tmpPath = `${finalPath}.${process.pid}.${Date.now()}.tmp`;
-  try {
-    fs.mkdirSync(path.dirname(finalPath), { recursive: true });
-    fs.writeFileSync(tmpPath, encoded);
-    fs.renameSync(tmpPath, finalPath);
-  } catch {
-    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
-  }
+    const finalPath = statePathFor(localPath, fileId);
+    const tmpPath = `${finalPath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        fs.mkdirSync(path.dirname(finalPath), { recursive: true });
+        fs.writeFileSync(tmpPath, encoded);
+        fs.renameSync(tmpPath, finalPath);
+    }
+    catch {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch { /* ignore */ }
+    }
 }
-
 // Best-effort cleanup when a file is deleted from the workspace, so
 // stale .yjs blobs don't accumulate. Failing to delete is not fatal.
 export function deleteBindingState(localPath, fileId) {
-  try { fs.unlinkSync(statePathFor(localPath, fileId)); } catch { /* ignore */ }
+    try {
+        fs.unlinkSync(statePathFor(localPath, fileId));
+    }
+    catch { /* ignore */ }
 }
+//# sourceMappingURL=yjs-binding-state.js.map

package/yjs-file-binding.d.ts

@@ -0,0 +1,32 @@
+import * as Y from 'yjs';
+import { type YjsUpdateStore } from './yjs-provider.js';
+export interface YjsFileBindingOptions {
+    debounceMs?: number;
+    onDiskWrite: (text: string) => void;
+    onDocStateChange?: ((encoded: Uint8Array) => void) | null;
+    initialDocState?: Uint8Array | null;
+    currentDiskText?: string | null;
+}
+export declare class YjsFileBinding {
+    readonly doc: Y.Doc;
+    readonly ytext: Y.Text;
+    private readonly store;
+    private readonly provider;
+    private readonly debounceMs;
+    private readonly onDiskWrite;
+    private readonly onDocStateChange;
+    private readonly initialDocState;
+    private readonly currentDiskText;
+    private flushTimer;
+    private lastDiskText;
+    private observer;
+    private stopped;
+    constructor(store: YjsUpdateStore, { debounceMs, onDiskWrite, onDocStateChange, initialDocState, currentDiskText, }: YjsFileBindingOptions);
+    start(): Promise<void>;
+    private _applyTextDiff;
+    private _emitDocState;
+    private _flushNow;
+    applyDiskText(newText: string): void;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=yjs-file-binding.d.ts.map