@spooky-sync/core 0.0.1-canary.345 → 0.0.1-canary.347

package/dist/index.d.ts

@@ -676,6 +676,19 @@ declare class CrdtManager {
   private checkLoaded;
   private tryImport;
   private refetchCanonical;
+  /**
+   * A first open reads the published document and the log at the same time,
+   * and a fold landing between the two hides the field from both: it
+   * publishes its snapshot, then deletes the rows the log query was about to
+   * return, after the published-document read came back empty. Nothing seen
+   * means nothing to verify, so the editor stayed empty until the next edit
+   * (a second device opening a just-created thread, under e2e load). Once the
+   * log has answered, a field that is still empty reads the published
+   * document again: the fold that took its rows committed before deleting
+   * them. Once per open; `first` is the first read (null with a local copy or
+   * a draft, which need none).
+   */
+  private recheckCanonical;
   private scheduleVerify;
   /**
    * After a fold: compare this device's document with the one the server

package/dist/index.js

@@ -2286,8 +2286,8 @@ function trimHistory(history, cap) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.345";
-const WASM_VERSION = "0.0.1-canary.345";
+const CORE_VERSION = "0.0.1-canary.347";
+const WASM_VERSION = "0.0.1-canary.347";
 const SURREAL_VERSION = "3.1.0";
 var DevToolsService = class DevToolsService {
 	version = CORE_VERSION;
@@ -13071,7 +13071,8 @@ var CrdtManager = class {
 			presenceSent: false,
 			ingesting: Promise.resolve(),
 			canonicalAnswered: false,
-			logSettled: false
+			logSettled: false,
+			recheck: null
 		};
 		session.handle = new CrdtField(table, recordId, field, kind, cursor, doc, { pushPresence: (state) => this.pushPresence(session, state) });
 		if (local.snapshot || fresh) session.handle.markLoaded();
@@ -13097,13 +13098,16 @@ var CrdtManager = class {
 		const [log, presence] = await Promise.all([logWatch, presenceWatch]);
 		session.disposers.push(log.stop);
 		if (presence) session.disposers.push(presence.stop);
-		log.settled.then(() => {
+		log.settled.then(async () => {
 			session.logSettled = true;
-			session.ingesting.then(() => this.checkLoaded(session));
+			await session.ingesting;
+			await this.recheckCanonical(session, canonical);
+			this.checkLoaded(session);
 		});
 		if (canonical) await this.serverWait(canonical);
 		if (!session.handle.hasContent() && !fresh) await this.serverWait(log.settled);
 		await session.ingesting;
+		if (session.logSettled) await this.serverWait(this.recheckCanonical(session, canonical));
 		this.scheduleFlush(session, 0);
 		this.logger.debug({
 			key,
@@ -13216,6 +13220,27 @@ var CrdtManager = class {
 			s.refetching = false;
 		}
 	}
+	/**
+	* A first open reads the published document and the log at the same time,
+	* and a fold landing between the two hides the field from both: it
+	* publishes its snapshot, then deletes the rows the log query was about to
+	* return, after the published-document read came back empty. Nothing seen
+	* means nothing to verify, so the editor stayed empty until the next edit
+	* (a second device opening a just-created thread, under e2e load). Once the
+	* log has answered, a field that is still empty reads the published
+	* document again: the fold that took its rows committed before deleting
+	* them. Once per open; `first` is the first read (null with a local copy or
+	* a draft, which need none).
+	*/
+	recheckCanonical(s, first) {
+		if (!first) return Promise.resolve();
+		s.recheck ??= (async () => {
+			await first;
+			await s.ingesting;
+			if (!s.handle.hasContent()) await this.refetchCanonical(s);
+		})();
+		return s.recheck;
+	}
 	scheduleVerify(s) {
 		if (s.verifyTimer) clearTimeout(s.verifyTimer);
 		s.verifyTimer = setTimeout(() => {
@@ -15897,7 +15922,7 @@ function createTabsCoordinator(config, s, host) {
 	return new TabsCoordinator({
 		tabId: s.tabId,
 		fingerprint: computeTabsFingerprint({
-			coreVersion: "0.0.1-canary.345",
+			coreVersion: "0.0.1-canary.347",
 			schemaHash: hash53(config.schemaSurql),
 			endpoint: config.database.endpoint ?? "",
 			namespace: config.database.namespace,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.345",
+  "version": "0.0.1-canary.347",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -75,8 +75,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.345",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.345",
+    "@spooky-sync/query-builder": "0.0.1-canary.347",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.347",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.1.0",
     "@surrealdb/wasm-native": "^3.3.4",

package/src/modules/crdt/crdt.test.ts

@@ -31,6 +31,8 @@ class World {
   storeDelayMs = 0;
   /** A connected but slow server: reads and the log's first answer wait for `release()`. */
   slow = false;
+  /** Only the log's first answer waits for `release()`; reads answer at once. */
+  slowLog = false;
   private held: Array<() => void> = [];
   release() {
     for (const go of this.held.splice(0)) go();
@@ -72,7 +74,7 @@ class World {
         this.watched.push(table);
         const w = { table, where, cb };
         this.watchers.add(w);
-        if (this.slow) {
+        if (this.slow || this.slowLog) {
           const settled = new Promise<void>((go) =>
             this.held.push(() => {
               cb(this.rowsFor(table, where));
@@ -419,6 +421,35 @@ describe('CRDT fields', () => {
     expect(text(fb)).toBe('Hello world');
   });
 
+  // threads-e2e 2026-10-22: a second device opening a just-created thread kept
+  // an empty editor. Its published-document read came back before the fold,
+  // and its log query answered after the fold had deleted the rows.
+  it('a first open still gets the content when a fold lands between its two reads', async () => {
+    const world = new World();
+    const a = world.client('user:a');
+    const fa = await a.manager.open('doc', 'doc:1', 'body');
+    fa.getDoc().getText('body').insert(0, 'shared seed');
+    fa.getDoc().commit();
+    await vi.advanceTimersByTimeAsync(400);
+    expect(world.log).toHaveLength(1);
+
+    world.slowLog = true;
+    const b = world.client('user:b');
+    const opening = b.manager.open('doc', 'doc:1', 'body');
+    // B's published-document read answers now (nothing published yet) while
+    // its log query is still out.
+    await vi.advanceTimersByTimeAsync(0);
+    expect(world.published.size).toBe(0);
+    await world.fold('doc:1', 'body', LoroDoc.fromSnapshot(fa.getDoc().export({ mode: 'snapshot' })));
+    expect(world.log).toHaveLength(0);
+    world.slowLog = false;
+    world.release();
+    await vi.advanceTimersByTimeAsync(10);
+    const fb = await opening;
+    expect(text(fb)).toBe('shared seed');
+    expect(fb.isLoaded()).toBe(true);
+  });
+
   it('report a document that differs from the published one at the same version', async () => {
     const world = new World();
     const warn = vi.fn();

package/src/modules/crdt/index.ts

@@ -99,6 +99,8 @@ interface Session {
   canonicalAnswered: boolean;
   /** The log watch delivered the server's first answer. */
   logSettled: boolean;
+  /** The second published-document read of a first open (see `recheckCanonical`). */
+  recheck: Promise<void> | null;
 }
 
 const LOCAL_TABLE = '_00_crdt_local';
@@ -307,6 +309,7 @@ export class CrdtManager {
       ingesting: Promise.resolve(),
       canonicalAnswered: false,
       logSettled: false,
+      recheck: null,
     };
     session.handle = new CrdtField(table, recordId, field, kind, cursor, doc, {
       pushPresence: (state) => this.pushPresence(session, state),
@@ -342,9 +345,11 @@ export class CrdtManager {
     const [log, presence] = await Promise.all([logWatch, presenceWatch]);
     session.disposers.push(log.stop);
     if (presence) session.disposers.push(presence.stop);
-    void log.settled.then(() => {
+    void log.settled.then(async () => {
       session.logSettled = true;
-      void session.ingesting.then(() => this.checkLoaded(session));
+      await session.ingesting;
+      await this.recheckCanonical(session, canonical);
+      this.checkLoaded(session);
     });
     // Offline the published document is read once the connection is back
     // instead of holding the open.
@@ -355,6 +360,7 @@ export class CrdtManager {
     // once the server's rows for it are in.
     if (!session.handle.hasContent() && !fresh) await this.serverWait(log.settled);
     await session.ingesting;
+    if (session.logSettled) await this.serverWait(this.recheckCanonical(session, canonical));
     // Edits a previous session made but never sent (closed tab, offline).
     this.scheduleFlush(session, 0);
     this.logger.debug({ key, peer: this.peer, Category: 'sp00ky-client::CrdtManager::open' }, 'CRDT field opened');
@@ -473,6 +479,28 @@ export class CrdtManager {
     }
   }
 
+  /**
+   * A first open reads the published document and the log at the same time,
+   * and a fold landing between the two hides the field from both: it
+   * publishes its snapshot, then deletes the rows the log query was about to
+   * return, after the published-document read came back empty. Nothing seen
+   * means nothing to verify, so the editor stayed empty until the next edit
+   * (a second device opening a just-created thread, under e2e load). Once the
+   * log has answered, a field that is still empty reads the published
+   * document again: the fold that took its rows committed before deleting
+   * them. Once per open; `first` is the first read (null with a local copy or
+   * a draft, which need none).
+   */
+  private recheckCanonical(s: Session, first: Promise<void> | null): Promise<void> {
+    if (!first) return Promise.resolve();
+    s.recheck ??= (async () => {
+      await first;
+      await s.ingesting;
+      if (!s.handle.hasContent()) await this.refetchCanonical(s);
+    })();
+    return s.recheck;
+  }
+
   // --- checking against the published document ---------------------
 
   private scheduleVerify(s: Session): void {