@spooky-sync/core 0.0.1-canary.329 → 0.0.1-canary.330

package/dist/index.d.ts

@@ -539,10 +539,25 @@ declare class CrdtField {
   private readonly host;
   private _onCursorUpdate;
   private pendingCursorUpdate;
+  private loaded;
+  private loadedListeners;
   constructor(table: string, recordId: string, fieldName: string, kind: CrdtKind, cursorsEnabled: boolean, doc: LoroDoc, host: CrdtFieldHost);
   getDoc(): LoroDoc;
   /** Whether the document holds anything yet (local state or edits). */
   hasContent(): boolean;
+  /**
+   * Whether the document is known: this device had it, it was handed a draft,
+   * or the server answered (with content, or that it has none yet). Until then
+   * an empty document means "not loaded", not "empty": show the column's text
+   * instead, and do not bind an editor (an editor binding an empty document
+   * creates structure that competes with the real one).
+   */
+  isLoaded(): boolean;
+  /** Runs `cb` once the field is loaded (at once if it already is). Returns
+   *  an unsubscribe. */
+  onLoaded(cb: () => void): () => void;
+  /** @internal The manager calls this when the document became known. */
+  markLoaded(): void;
   /** Publish this session's presence (an `EphemeralStore` encoding, e.g. the
    *  editor's cursor). No-op unless the field is `@cursor`. */
   pushCursorState(encoded: Uint8Array): void;
@@ -651,6 +666,9 @@ declare class CrdtManager {
    */
   private serverWait;
   private ingest;
+  /** Mark the field loaded once its content arrived, or the server answered
+   *  both reads (the published document and the log) with nothing. */
+  private checkLoaded;
   private tryImport;
   private refetchCanonical;
   private scheduleVerify;

package/dist/index.js

@@ -2188,8 +2188,8 @@ function trimHistory(history, cap) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.329";
-const WASM_VERSION = "0.0.1-canary.329";
+const CORE_VERSION = "0.0.1-canary.330";
+const WASM_VERSION = "0.0.1-canary.330";
 const SURREAL_VERSION = "3.1.0";
 var DevToolsService = class DevToolsService {
 	version = CORE_VERSION;
@@ -3350,7 +3350,8 @@ const clearMembershipDirty = (hashes) => (s) => ({
 	...s,
 	membershipDirty: withoutAll(s.membershipDirty, hashes)
 });
-/** Record local body versions; dirties every query whose membership names one of them. */
+/** Record local body versions; dirties every query whose membership or
+*  related rows (subquery children, e.g. a thread's author) name one of them. */
 const setVersions = (entries) => (s) => {
 	if (entries.length === 0) return s;
 	const versions = new Map(s.versions);
@@ -3361,7 +3362,10 @@ const setVersions = (entries) => (s) => {
 	}
 	if (changed.size === 0) return s;
 	const dirty = [];
-	for (const [hash, entry] of s.queries) if (entry.remoteArray.some(([id]) => changed.has(id)) || entry.localArray.some(([id]) => changed.has(id))) dirty.push(hash);
+	for (const [hash, entry] of s.queries) {
+		const names = (rows) => rows.some(([id]) => changed.has(id));
+		if (names(entry.remoteArray) || names(entry.localArray) || names(entry.subqueryRemoteArray)) dirty.push(hash);
+	}
 	return {
 		...s,
 		versions,
@@ -8570,6 +8574,11 @@ var RemoteDatabaseService = class extends AbstractDatabaseService {
 			}, "forceClose failed; treating the socket as gone anyway");
 		}
 	}
+	/** Resolve once no connect is in flight, for calls that go to the SDK
+	*  client directly (sign-in, sign-up) and so skip `beforeQuery`. */
+	whenConnected() {
+		return this.beforeQuery();
+	}
 	/**
 	* Hold statements while a connect is in flight.
 	*
@@ -12277,9 +12286,10 @@ var AuthService = class {
 		if (missingParams.length > 0) throw new Error(`Missing required signup params for '${accessName}': ${missingParams.join(", ")}`);
 		this.logger.info({
 			accessName,
-			runtimeParams,
+			params: Object.keys(runtimeParams),
 			Category: "sp00ky-client::AuthService::signUp"
 		}, "Attempting signup");
+		await this.remote.whenConnected();
 		const { access } = await this.remote.getClient().signup({
 			access: accessName,
 			variables: runtimeParams
@@ -12297,6 +12307,7 @@ var AuthService = class {
 			accessName,
 			Category: "sp00ky-client::AuthService::signIn"
 		}, "Attempting signin");
+		await this.remote.whenConnected();
 		const { access } = await this.remote.getClient().signin({
 			access: accessName,
 			variables: runtimeParams
@@ -12434,6 +12445,8 @@ function cursorColorFromName(name) {
 var CrdtField = class {
 	_onCursorUpdate = null;
 	pendingCursorUpdate = null;
+	loaded = false;
+	loadedListeners = /* @__PURE__ */ new Set();
 	constructor(table, recordId, fieldName, kind, cursorsEnabled, doc, host) {
 		this.table = table;
 		this.recordId = recordId;
@@ -12450,6 +12463,35 @@ var CrdtField = class {
 	hasContent() {
 		return this.doc.oplogVersion().length() > 0;
 	}
+	/**
+	* Whether the document is known: this device had it, it was handed a draft,
+	* or the server answered (with content, or that it has none yet). Until then
+	* an empty document means "not loaded", not "empty": show the column's text
+	* instead, and do not bind an editor (an editor binding an empty document
+	* creates structure that competes with the real one).
+	*/
+	isLoaded() {
+		return this.loaded;
+	}
+	/** Runs `cb` once the field is loaded (at once if it already is). Returns
+	*  an unsubscribe. */
+	onLoaded(cb) {
+		if (this.loaded) {
+			cb();
+			return () => {};
+		}
+		this.loadedListeners.add(cb);
+		return () => this.loadedListeners.delete(cb);
+	}
+	/** @internal The manager calls this when the document became known. */
+	markLoaded() {
+		if (this.loaded) return;
+		this.loaded = true;
+		for (const cb of [...this.loadedListeners]) try {
+			cb();
+		} catch {}
+		this.loadedListeners.clear();
+	}
 	/** Publish this session's presence (an `EphemeralStore` encoding, e.g. the
 	*  editor's cursor). No-op unless the field is `@cursor`. */
 	pushCursorState(encoded) {
@@ -12608,7 +12650,10 @@ var CrdtManager = class {
 		this.debounceMs = debounceMs;
 		this.logger = logger.child({ service: "CrdtManager" });
 		this.connectionUnsubscribes.push(this.remote.subscribeConnection("connected", () => {
-			for (const s of this.sessions.values()) this.scheduleFlush(s, 0);
+			for (const s of this.sessions.values()) {
+				this.scheduleFlush(s, 0);
+				if (!s.handle.isLoaded() && !s.canonicalAnswered) this.refetchCanonical(s);
+			}
 		}));
 	}
 	/** Hand over the runtime ports. Called once by the client facade. */
@@ -12730,9 +12775,12 @@ var CrdtManager = class {
 			presenceTimer: null,
 			presencePending: null,
 			presenceSent: false,
-			ingesting: Promise.resolve()
+			ingesting: Promise.resolve(),
+			canonicalAnswered: false,
+			logSettled: false
 		};
 		session.handle = new CrdtField(table, recordId, field, kind, cursor, doc, { pushPresence: (state) => this.pushPresence(session, state) });
+		if (local.snapshot || fresh) session.handle.markLoaded();
 		this.sessions.set(key, session);
 		this.ensureClaimed();
 		if (!local.snapshot && !fresh) await this.serverWait(this.refetchCanonical(session));
@@ -12749,6 +12797,10 @@ var CrdtManager = class {
 			session.ingesting = session.ingesting.then(() => this.ingest(session, rows));
 		});
 		session.disposers.push(log.stop);
+		log.settled.then(() => {
+			session.logSettled = true;
+			session.ingesting.then(() => this.checkLoaded(session));
+		});
 		if (cursor) {
 			const presence = await ports.watch(`${table}${PRESENCE_SUFFIX}`, {
 				doc: recordId,
@@ -12822,9 +12874,15 @@ var CrdtManager = class {
 		if (blobs.length === 0) return;
 		let pending = false;
 		for (const blob of blobs) if (this.tryImport(s.doc, blob, s.key)?.pending) pending = true;
+		this.checkLoaded(s);
 		this.schedulePersist(s);
 		if (pending) this.refetchCanonical(s);
 	}
+	/** Mark the field loaded once its content arrived, or the server answered
+	*  both reads (the published document and the log) with nothing. */
+	checkLoaded(s) {
+		if (s.handle.hasContent() || s.canonicalAnswered && s.logSettled) s.handle.markLoaded();
+	}
 	tryImport(doc, blob, key) {
 		try {
 			const status = doc.import(blob);
@@ -12852,6 +12910,8 @@ var CrdtManager = class {
 				s.local.rev = Math.max(s.local.rev, row?.rev ?? 0);
 				this.schedulePersist(s);
 			}
+			s.canonicalAnswered = true;
+			this.checkLoaded(s);
 		} catch (e) {
 			this.logger.debug({
 				key: s.key,
@@ -13340,8 +13400,8 @@ var TabBrokerClient = class {
 	lastPingAt = 0;
 	closed = false;
 	helloState = null;
-	constructor(workerUrl, tabId, events, logger) {
-		this.workerUrl = workerUrl;
+	constructor(createWorker, tabId, events, logger) {
+		this.createWorker = createWorker;
 		this.tabId = tabId;
 		this.events = events;
 		this.logger = logger;
@@ -13365,10 +13425,7 @@ var TabBrokerClient = class {
 			};
 			let worker;
 			try {
-				worker = new SharedWorker(this.workerUrl, {
-					type: "module",
-					name: "sp00ky-tabs-broker"
-				});
+				worker = this.createWorker();
 			} catch (e) {
 				reject(e);
 				return;
@@ -13748,7 +13805,10 @@ var TabsCoordinator = class {
 		this.deps = deps;
 		this.fingerprint = deps.fingerprint;
 		this.bucketId = "anon";
-		this.broker = new TabBrokerClient(new URL("./tabs-broker-worker.js", import.meta.url), deps.tabId, {
+		this.broker = new TabBrokerClient(() => new SharedWorker(new URL("./tabs-broker-worker.js", import.meta.url), {
+			type: "module",
+			name: "sp00ky-tabs-broker"
+		}), deps.tabId, {
 			onBecomeLeader: (msg) => this.enqueue(() => this.promote(msg)),
 			onDemote: (leadershipId) => this.enqueue(() => this.demote(leadershipId)),
 			onLeaderReady: (leadershipId, leaderTabId) => {
@@ -15393,7 +15453,7 @@ function createTabsCoordinator(config, s, host) {
 	return new TabsCoordinator({
 		tabId: s.tabId,
 		fingerprint: computeTabsFingerprint({
-			coreVersion: "0.0.1-canary.329",
+			coreVersion: "0.0.1-canary.330",
 			schemaHash: hash53(config.schemaSurql),
 			endpoint: config.database.endpoint ?? "",
 			namespace: config.database.namespace,

package/dist/types.d.ts

@@ -748,6 +748,9 @@ declare class RemoteDatabaseService extends AbstractDatabaseService {
    * `disconnected`, which is what drives the supervisor's revive loop.
    */
   forceClose(): Promise<void>;
+  /** Resolve once no connect is in flight, for calls that go to the SDK
+   *  client directly (sign-in, sign-up) and so skip `beforeQuery`. */
+  whenConnected(): Promise<void>;
   /**
    * Hold statements while a connect is in flight.
    *

package/package.json

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

package/src/modules/auth/auth.local-first.test.ts

@@ -181,3 +181,48 @@ describe('the announced user id', () => {
   );
 });
 
+
+describe('signIn and signUp', () => {
+  function makeSigning() {
+    let connect!: () => void;
+    const connected = new Promise<void>((resolve) => (connect = resolve));
+    const sent: string[] = [];
+    const token = jwt({ AC: 'account', ID: 'user:abc' });
+    const remote = {
+      query: vi.fn(async () => [[{ id: new RecordId('user', 'abc') }]]),
+      setAuthToken: vi.fn(),
+      whenConnected: vi.fn(() => connected),
+      getClient: () => ({
+        signin: vi.fn(async () => (sent.push('signin'), { access: token })),
+        signup: vi.fn(async () => (sent.push('signup'), { access: token })),
+        authenticate: vi.fn(async () => undefined),
+        invalidate: vi.fn(async () => undefined),
+      }),
+    } as any;
+    const persistence = { get: vi.fn(async () => null), set: vi.fn(async () => undefined), remove: vi.fn(async () => undefined) } as any;
+    const params = { username: {}, password: {} };
+    const schema = { access: { account: { signIn: { params }, signup: { params } } } } as any;
+    const logger = silentLogger();
+    return { auth: new AuthService(schema, remote, persistence, logger), connect, sent, logger };
+  }
+
+  it('wait for a connect in flight: a socket without its namespace refuses them', async () => {
+    for (const call of ['signIn', 'signUp'] as const) {
+      const { auth, connect, sent } = makeSigning();
+      const done = auth[call]('account' as never, { username: 'u', password: 'secret' } as never).catch(() => undefined);
+      for (let i = 0; i < 5; i++) await Promise.resolve();
+      expect(sent).toEqual([]);
+      connect();
+      await done;
+      expect(sent).toEqual([call === 'signIn' ? 'signin' : 'signup']);
+    }
+  });
+
+  it('never log the password', async () => {
+    const { auth, connect, logger } = makeSigning();
+    connect();
+    await auth.signUp('account' as never, { username: 'u', password: 'hunter2' } as never).catch(() => undefined);
+    const logged = JSON.stringify([...logger.info.mock.calls, ...logger.debug.mock.calls]);
+    expect(logged).not.toContain('hunter2');
+  });
+});

package/src/modules/auth/index.ts

@@ -658,11 +658,17 @@ export class AuthService<S extends SchemaStructure> {
       );
     }
 
+    // Parameter names only: the values hold the password (and whatever else
+    // the app signs up with), and logs may leave the device.
     this.logger.info(
-      { accessName, runtimeParams, Category: 'sp00ky-client::AuthService::signUp' },
+      { accessName, params: Object.keys(runtimeParams), Category: 'sp00ky-client::AuthService::signUp' },
       'Attempting signup'
     );
 
+    // Straight to the SDK client, so wait out a connect in flight: on a socket
+    // without its namespace yet the call fails with "There is no namespace
+    // and/or database selected" (a sign-up right after the page loaded).
+    await this.remote.whenConnected();
     const { access } = await this.remote.getClient().signup({
       access: accessName,
       variables: runtimeParams,
@@ -704,6 +710,7 @@ export class AuthService<S extends SchemaStructure> {
       'Attempting signin'
     );
 
+    await this.remote.whenConnected(); // see signUp
     const { access } = await this.remote.getClient().signin({
       access: accessName,
       variables: runtimeParams,

package/src/modules/crdt/crdt-field.ts

@@ -34,6 +34,8 @@ export interface CrdtFieldHost {
 export class CrdtField {
   private _onCursorUpdate: ((data: Uint8Array) => void) | null = null;
   private pendingCursorUpdate: Uint8Array | null = null;
+  private loaded = false;
+  private loadedListeners = new Set<() => void>();
 
   constructor(
     readonly table: string,
@@ -54,6 +56,42 @@ export class CrdtField {
     return this.doc.oplogVersion().length() > 0;
   }
 
+  /**
+   * Whether the document is known: this device had it, it was handed a draft,
+   * or the server answered (with content, or that it has none yet). Until then
+   * an empty document means "not loaded", not "empty": show the column's text
+   * instead, and do not bind an editor (an editor binding an empty document
+   * creates structure that competes with the real one).
+   */
+  isLoaded(): boolean {
+    return this.loaded;
+  }
+
+  /** Runs `cb` once the field is loaded (at once if it already is). Returns
+   *  an unsubscribe. */
+  onLoaded(cb: () => void): () => void {
+    if (this.loaded) {
+      cb();
+      return () => {};
+    }
+    this.loadedListeners.add(cb);
+    return () => this.loadedListeners.delete(cb);
+  }
+
+  /** @internal The manager calls this when the document became known. */
+  markLoaded(): void {
+    if (this.loaded) return;
+    this.loaded = true;
+    for (const cb of [...this.loadedListeners]) {
+      try {
+        cb();
+      } catch {
+        /* a listener's failure is its own */
+      }
+    }
+    this.loadedListeners.clear();
+  }
+
   /** Publish this session's presence (an `EphemeralStore` encoding, e.g. the
    *  editor's cursor). No-op unless the field is `@cursor`. */
   pushCursorState(encoded: Uint8Array): void {

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

@@ -29,6 +29,12 @@ class World {
   hang = false;
   /** A slow device store: each local write takes this long (real timers). */
   storeDelayMs = 0;
+  /** A connected but slow server: reads and the log's first answer wait for `release()`. */
+  slow = false;
+  private held: Array<() => void> = [];
+  release() {
+    for (const go of this.held.splice(0)) go();
+  }
   private watchers = new Set<{ table: string; where: Record<string, unknown>; cb: (rows: any[]) => void }>();
 
   client(user: string, store = new Map<string, any>(), logger: any = silent) {
@@ -44,6 +50,7 @@ class World {
       subscribeConnection: () => () => {},
       getStatus: () => (this.online ? 'connected' : 'disconnected'),
       query: async (sql: string, vars: any) => {
+        if (this.slow) await new Promise<void>((go) => this.held.push(go));
         if (!this.online && this.hang) return new Promise(() => {});
         if (!this.online) throw new Error('not connected');
         if (sql.startsWith('CREATE')) {
@@ -62,6 +69,15 @@ class World {
       watch: async (table, where, cb) => {
         const w = { table, where, cb };
         this.watchers.add(w);
+        if (this.slow) {
+          const settled = new Promise<void>((go) =>
+            this.held.push(() => {
+              cb(this.rowsFor(table, where));
+              go();
+            })
+          );
+          return { stop: () => void this.watchers.delete(w), settled };
+        }
         cb(this.rowsFor(table, where));
         return { stop: () => void this.watchers.delete(w), settled: Promise.resolve() };
       },
@@ -220,6 +236,46 @@ describe('CRDT fields', () => {
     expect([...store.values()].some((row) => row.snapshot)).toBe(true);
   });
 
+  it('a field is loaded once the server answers, and at once with a local copy or a draft', async () => {
+    const world = new World();
+    const server = new LoroDoc();
+    server.getText('body').insert(0, 'from the server');
+    server.commit();
+    await world.fold('doc:1', 'body', server);
+    world.slow = true;
+    const store = new Map<string, any>();
+    const a = world.client('user:a', store);
+    const opening = a.manager.open('doc', 'doc:1', 'body');
+    await vi.advanceTimersByTimeAsync(9000);
+    const f = await opening;
+    // Handed out after the bounded wait, but empty only because nothing came.
+    expect(text(f)).toBe('');
+    expect(f.isLoaded()).toBe(false);
+    let loaded = 0;
+    f.onLoaded(() => loaded++);
+    world.release();
+    await realWait();
+    expect(text(f)).toBe('from the server');
+    expect(f.isLoaded()).toBe(true);
+    expect(loaded).toBe(1);
+    await a.manager.close('doc', 'doc:1', 'body');
+
+    // This device has it now: loaded before the server says anything.
+    const again = await (async () => {
+      const opening2 = a.manager.open('doc', 'doc:1', 'body');
+      await vi.advanceTimersByTimeAsync(9000);
+      return opening2;
+    })();
+    expect(again.isLoaded()).toBe(true);
+    world.release();
+
+    const draft = await a.manager.createDraft('doc', 'body');
+    draft.getDoc().getText('body').insert(0, 'new');
+    draft.getDoc().commit();
+    const fresh = await a.manager.open('doc', 'doc:2', 'body', draft);
+    expect(fresh.isLoaded()).toBe(true);
+  });
+
   it('a reopen right after a close starts from what the close saved', async () => {
     vi.useRealTimers();
     const world = new World();

package/src/modules/crdt/index.ts

@@ -90,6 +90,10 @@ interface Session {
   presenceSent: boolean;
   /** The latest import of delivered rows (chained, so awaiting it awaits all). */
   ingesting: Promise<void>;
+  /** The server answered the published-document read (with a row or none). */
+  canonicalAnswered: boolean;
+  /** The log watch delivered the server's first answer. */
+  logSettled: boolean;
 }
 
 const LOCAL_TABLE = '_00_crdt_local';
@@ -130,7 +134,11 @@ export class CrdtManager {
     this.logger = logger.child({ service: 'CrdtManager' });
     this.connectionUnsubscribes.push(
       this.remote.subscribeConnection('connected', () => {
-        for (const s of this.sessions.values()) this.scheduleFlush(s, 0);
+        for (const s of this.sessions.values()) {
+          this.scheduleFlush(s, 0);
+          // Opened while the server could not answer: read it now.
+          if (!s.handle.isLoaded() && !s.canonicalAnswered) void this.refetchCanonical(s);
+        }
       })
     );
   }
@@ -289,10 +297,14 @@ export class CrdtManager {
       presencePending: null,
       presenceSent: false,
       ingesting: Promise.resolve(),
+      canonicalAnswered: false,
+      logSettled: false,
     };
     session.handle = new CrdtField(table, recordId, field, kind, cursor, doc, {
       pushPresence: (state) => this.pushPresence(session, state),
     });
+    // Known from the start: this device's copy, or a record just created here.
+    if (local.snapshot || fresh) session.handle.markLoaded();
     this.sessions.set(key, session);
 
     // Claimed now, so the first edits do not wait on the round trip.
@@ -315,6 +327,10 @@ export class CrdtManager {
       session.ingesting = session.ingesting.then(() => this.ingest(session, rows));
     });
     session.disposers.push(log.stop);
+    void log.settled.then(() => {
+      session.logSettled = true;
+      void session.ingesting.then(() => this.checkLoaded(session));
+    });
     if (cursor) {
       const presence = await ports.watch(`${table}${PRESENCE_SUFFIX}`, { doc: recordId, field }, (rows) =>
         this.ingestPresence(session, rows)
@@ -398,12 +414,19 @@ export class CrdtManager {
       const status = this.tryImport(s.doc, blob, s.key);
       if (status?.pending) pending = true;
     }
+    this.checkLoaded(s);
     this.schedulePersist(s);
     // Ops depending on rows that were folded away before this device saw
     // them: the published snapshot holds those predecessors.
     if (pending) void this.refetchCanonical(s);
   }
 
+  /** Mark the field loaded once its content arrived, or the server answered
+   *  both reads (the published document and the log) with nothing. */
+  private checkLoaded(s: Session): void {
+    if (s.handle.hasContent() || (s.canonicalAnswered && s.logSettled)) s.handle.markLoaded();
+  }
+
   private tryImport(doc: LoroDoc, blob: Uint8Array, key: string): { pending: boolean } | null {
     try {
       const status = doc.import(blob);
@@ -428,6 +451,8 @@ export class CrdtManager {
         s.local.rev = Math.max(s.local.rev, row?.rev ?? 0);
         this.schedulePersist(s);
       }
+      s.canonicalAnswered = true;
+      this.checkLoaded(s);
     } catch (e) {
       // Offline or no published document yet: the log rows still arrive.
       this.logger.debug({ key: s.key, error: String(e), Category: 'sp00ky-client::CrdtManager::refetch' }, 'No canonical CRDT document fetched');

package/src/services/database/remote.ts

@@ -259,6 +259,12 @@ export class RemoteDatabaseService extends AbstractDatabaseService {
     }
   }
 
+  /** Resolve once no connect is in flight, for calls that go to the SDK
+   *  client directly (sign-in, sign-up) and so skip `beforeQuery`. */
+  whenConnected(): Promise<void> {
+    return this.beforeQuery();
+  }
+
   /**
    * Hold statements while a connect is in flight.
    *

package/src/services/tabs/broker-client.ts

@@ -62,7 +62,8 @@ export class TabBrokerClient {
   private helloState: BrokerHello | null = null;
 
   constructor(
-    private workerUrl: URL,
+    /** Starts (or joins) the broker SharedWorker. */
+    private createWorker: () => SharedWorker,
     readonly tabId: TabId,
     private events: BrokerClientEvents,
     private logger: Logger
@@ -88,7 +89,7 @@ export class TabBrokerClient {
       };
       let worker: SharedWorker;
       try {
-        worker = new SharedWorker(this.workerUrl, { type: 'module', name: 'sp00ky-tabs-broker' });
+        worker = this.createWorker();
       } catch (e) {
         reject(e);
         return;

package/src/services/tabs/coordinator.ts

@@ -253,11 +253,19 @@ export class TabsCoordinator {
   ) {
     this.fingerprint = deps.fingerprint;
     this.bucketId = 'anon';
-    // The URL is built HERE (same directory as the worker source) so the
-    // published flat bundle's rewritten './tabs-broker-worker.js' resolves at
-    // the dist top level, exactly like the sqlite worker URL does.
+    // The worker is created HERE (same directory as its source) and in this
+    // exact shape, `new SharedWorker(new URL('./x.ts', import.meta.url))`:
+    // the published flat bundle rewrites the name to './tabs-broker-worker.js'
+    // at the dist top level, like the sqlite worker, and a bundler that builds
+    // core from source (Vite) only compiles a worker written in one expression.
+    // Passing the URL around instead shipped the raw `.ts` file there, which no
+    // browser runs, so every tab fell back to running alone.
     this.broker = new TabBrokerClient(
-      new URL('./tabs-broker-worker.ts', import.meta.url),
+      () =>
+        new SharedWorker(new URL('./tabs-broker-worker.ts', import.meta.url), {
+          type: 'module',
+          name: 'sp00ky-tabs-broker',
+        }),
       deps.tabId,
       {
         onBecomeLeader: (msg) => this.enqueue(() => this.promote(msg)),

package/src/state/reducers.test.ts

@@ -175,10 +175,12 @@ describe('versions', () => {
       e('a', { remoteArray: [['thing:1', 1]] }),
       e('b', { localArray: [['thing:2', 1]] }),
       e('c'),
+      // A related row (a thread's author): a new body must re-render the list.
+      e('d', { subqueryRemoteArray: [['user:1', 1]] }),
     ]);
     expect(R.setVersions([])(s0)).toBe(s0);
-    const s1 = R.setVersions([['thing:1', 1], ['thing:2', 1], ['thing:9', 1]])(s0);
-    expect([...s1.dirty].sort()).toEqual(['a', 'b']);
+    const s1 = R.setVersions([['thing:1', 1], ['thing:2', 1], ['thing:9', 1], ['user:1', 2]])(s0);
+    expect([...s1.dirty].sort()).toEqual(['a', 'b', 'd']);
     expect(R.setVersions([['thing:1', 1]])(s1)).toBe(s1);
     const s2 = R.deleteVersions(['thing:9', 'nope'])(s1);
     expect(s2.versions.has('thing:9')).toBe(false);

package/src/state/reducers.ts

@@ -325,7 +325,8 @@ export const clearMembershipDirty =
 
 // ---- versions --------------------------------------------------------------
 
-/** Record local body versions; dirties every query whose membership names one of them. */
+/** Record local body versions; dirties every query whose membership or
+ *  related rows (subquery children, e.g. a thread's author) name one of them. */
 export const setVersions =
   (entries: ReadonlyArray<readonly [string, number]>): Reducer =>
   (s) => {
@@ -341,7 +342,8 @@ export const setVersions =
     if (changed.size === 0) return s;
     const dirty: QueryHash[] = [];
     for (const [hash, entry] of s.queries) {
-      if (entry.remoteArray.some(([id]) => changed.has(id)) || entry.localArray.some(([id]) => changed.has(id))) {
+      const names = (rows: RecordVersionArray) => rows.some(([id]) => changed.has(id));
+      if (names(entry.remoteArray) || names(entry.localArray) || names(entry.subqueryRemoteArray)) {
         dirty.push(hash);
       }
     }