@assistant-ui/core 0.3.14 → 0.3.16

package/src/runtimes/external-store/external-store-thread-runtime-core.ts

@@ -16,9 +16,13 @@ import type {
 import {
   getExternalStoreMessages,
   bindExternalStoreMessage,
+  FALLBACK_ID_PREFIX,
 } from "../../runtime/utils/external-store-message";
 import { ThreadMessageConverter } from "./thread-message-converter";
-import { getAutoStatus, isAutoStatus } from "../../runtime/utils/auto-status";
+import {
+  getContentAutoStatus,
+  isAutoStatus,
+} from "../../runtime/utils/auto-status";
 import {
   fromThreadMessageLike,
   type ThreadMessageLike,
@@ -39,8 +43,11 @@ import {
   MessageRepository,
 } from "../../runtime/utils/message-repository";
 import { generateId } from "../../utils/id";
-import { ToolInvocationTracker } from "../tool-invocations/ToolInvocationTracker";
-import { EMPTY_QUEUE_ITEMS } from "../../store/scopes/queue-item";
+import {
+  ToolInvocationTracker,
+  type ToolExecutionStatus,
+} from "../tool-invocations/ToolInvocationTracker";
+import { EMPTY_QUEUE_ITEMS } from "../../runtime/queue/queue-item";
 import type { QuoteInfo } from "../../types/quote";
 import {
   captureThreadRuntimeGeneration,
@@ -110,6 +117,7 @@ export class ExternalStoreThreadRuntimeCore
   }
   // Unlike `isLoading`: pass `undefined` through to preserve the `getThreadState` fallback.
   public get isRunning(): boolean | undefined {
+    if (this._hasExecutingTools(this._store)) return true;
     return this._store.isRunning;
   }
 
@@ -136,6 +144,16 @@ export class ExternalStoreThreadRuntimeCore
 
   private _converter = new ThreadMessageConverter();
 
+  // Ids the host was asked to delete via onDelete. The snapshot pass evicts
+  // them from the repository once the host's array no longer carries them;
+  // an id the host kept is dropped from the set without eviction.
+  // Branch-changing mutations (edit, branch switch, reload) invalidate the
+  // set, because after them the incoming array omits off-branch ids for
+  // reasons unrelated to deletion. Plain tail sends do not clear: a tail
+  // append cannot make a visible id absent, so id-absence stays unambiguous
+  // and a delete whose confirmation races a send keeps its eviction.
+  private _pendingDeleteEvictions = new Set<string>();
+
   private _store!: ExternalStoreAdapter<any>;
 
   private _getInitializePromise?: () => Promise<unknown> | undefined;
@@ -153,6 +171,51 @@ export class ExternalStoreThreadRuntimeCore
    * snapshot — only when `adapter.unstable_enableToolInvocations === true`.
    */
   private _toolInvocations: ToolInvocationTracker | null = null;
+  private _toolStatuses: ReadonlyMap<string, ToolExecutionStatus> = new Map();
+  private _effectiveIsRunning = false;
+  private _inTrackerUpdate = false;
+  private _pendingRunningRefresh = false;
+
+  /**
+   * Tracker mutations initiated by this class (setState, reset) can publish
+   * status changes synchronously. Re-entering the snapshot pipeline from
+   * inside them would feed the tracker a stale snapshot and consume the
+   * restore arming a reset just installed, so the running refresh is
+   * deferred until the mutation returns and stays off the tracker.
+   */
+  private _runTrackerUpdate(fn: () => void): void {
+    this._inTrackerUpdate = true;
+    try {
+      fn();
+    } finally {
+      this._inTrackerUpdate = false;
+    }
+    if (this._pendingRunningRefresh) {
+      this._pendingRunningRefresh = false;
+      this._refreshEffectiveIsRunning();
+    }
+  }
+
+  private _refreshEffectiveIsRunning(): void {
+    const isRunning = this._getEffectiveIsRunning(this._store);
+    if (this._effectiveIsRunning === isRunning) return;
+    this._effectiveIsRunning = isRunning;
+    this._notifyEventSubscribers(isRunning ? "runStart" : "runEnd", {});
+    this._notifySubscribers();
+  }
+
+  private _hasExecutingTools(store: ExternalStoreAdapter<any>): boolean {
+    if (store.unstable_enableToolInvocations !== true) return false;
+    if (this._toolInvocations === null) return false;
+    for (const status of this._toolStatuses.values()) {
+      if (status.type === "executing") return true;
+    }
+    return false;
+  }
+
+  private _getEffectiveIsRunning(store: ExternalStoreAdapter<any>): boolean {
+    return (store.isRunning ?? false) || this._hasExecutingTools(store);
+  }
 
   public override beginEdit(messageId: string) {
     if (!this._store.onEdit)
@@ -172,12 +235,17 @@ export class ExternalStoreThreadRuntimeCore
   public __internal_setAdapter(store: ExternalStoreAdapter<any>) {
     if (this._store === store) return;
 
-    const isRunning = store.isRunning ?? false;
+    this._updateStoreSnapshot(store);
+  }
+
+  private _updateStoreSnapshot(store: ExternalStoreAdapter<any>) {
+    const previousIsRunning = this._effectiveIsRunning;
     this.isDisabled = store.isDisabled ?? false;
     this.isSendDisabled = store.isSendDisabled ?? false;
 
     const oldStore = this._store as ExternalStoreAdapter<any> | undefined;
     this._store = store;
+    const isRunning = this._getEffectiveIsRunning(store);
     if (oldStore?.queue !== store.queue) {
       this._transformedQueue = undefined;
       store.queue?.__internal_setDispatchTransform?.((message) => {
@@ -229,7 +297,8 @@ export class ExternalStoreThreadRuntimeCore
       if (
         oldStore &&
         oldStore.isRunning === store.isRunning &&
-        oldStore.messageRepository === store.messageRepository
+        oldStore.messageRepository === store.messageRepository &&
+        previousIsRunning === isRunning
       ) {
         this._notifySubscribers();
         return;
@@ -252,6 +321,7 @@ export class ExternalStoreThreadRuntimeCore
             this.repository.deleteMessage(message.id);
           }
         }
+        this._pendingDeleteEvictions.clear();
         this.repository.resetHead(headId);
         messages = this.repository.getMessages();
       }
@@ -264,7 +334,8 @@ export class ExternalStoreThreadRuntimeCore
           this._converter = new ThreadMessageConverter();
         } else if (
           oldStore.isRunning === store.isRunning &&
-          oldStore.messages === store.messages
+          oldStore.messages === store.messages &&
+          previousIsRunning === isRunning
         ) {
           this._notifySubscribers();
           // no conversion update
@@ -278,27 +349,31 @@ export class ExternalStoreThreadRuntimeCore
             if (!store.convertMessage) return m;
 
             const isLast = idx === (store.messages?.length ?? 0) - 1;
-            const autoStatus = getAutoStatus(
-              isLast,
-              isRunning,
-              false,
-              false,
-              undefined,
-            );
+            const fallbackId = `${FALLBACK_ID_PREFIX}${idx}`;
 
             if (
               cache &&
               (cache.role !== "assistant" ||
                 !isAutoStatus(cache.status) ||
-                cache.status === autoStatus)
-            )
+                cache.status ===
+                  getContentAutoStatus(cache.content, isLast, isRunning))
+            ) {
+              if (
+                cache.id.startsWith(FALLBACK_ID_PREFIX) &&
+                cache.id !== fallbackId
+              ) {
+                const updated = { ...cache, id: fallbackId };
+                bindExternalStoreMessage(updated, m);
+                return updated;
+              }
               return cache;
+            }
 
             const messageLike = store.convertMessage(m, idx);
             const newMessage = fromThreadMessageLike(
               messageLike,
-              idx.toString(),
-              autoStatus,
+              fallbackId,
+              getContentAutoStatus(messageLike.content, isLast, isRunning),
             );
             bindExternalStoreMessage(newMessage, m);
             return newMessage;
@@ -324,6 +399,20 @@ export class ExternalStoreThreadRuntimeCore
         const parent = messages[i - 1];
         this.repository.addOrUpdateMessage(parent?.id ?? null, message);
       }
+
+      if (this._pendingDeleteEvictions.size > 0) {
+        const incomingIds = new Set(messages.map((m) => m.id));
+        for (const id of this._pendingDeleteEvictions) {
+          this._pendingDeleteEvictions.delete(id);
+          if (incomingIds.has(id)) continue;
+          try {
+            this.repository.getMessage(id);
+          } catch {
+            continue;
+          }
+          this.repository.deleteMessage(id);
+        }
+      }
     } else {
       throw new Error(
         "ExternalStoreAdapter must provide either 'messages' or 'messageRepository'",
@@ -333,8 +422,9 @@ export class ExternalStoreThreadRuntimeCore
     // Common logic for both paths
     if (messages.length > 0) this.ensureInitialized();
 
-    if ((oldStore?.isRunning ?? false) !== (store.isRunning ?? false)) {
-      if (store.isRunning) {
+    this._effectiveIsRunning = isRunning;
+    if (previousIsRunning !== isRunning) {
+      if (isRunning) {
         this._notifyEventSubscribers("runStart", {});
       } else {
         this._notifyEventSubscribers("runEnd", {});
@@ -361,7 +451,7 @@ export class ExternalStoreThreadRuntimeCore
 
     this._messages = this.repository.getMessages();
 
-    this._driveToolInvocations();
+    this._runTrackerUpdate(() => this._driveToolInvocations());
 
     this._notifySubscribers();
   }
@@ -380,6 +470,7 @@ export class ExternalStoreThreadRuntimeCore
       if (this._toolInvocations) {
         this._toolInvocations.reset();
         this._toolInvocations = null;
+        this._toolStatuses = new Map();
         this._store.setToolStatuses?.({});
       }
       return;
@@ -423,7 +514,19 @@ export class ExternalStoreThreadRuntimeCore
             }
           },
           onStatusesChange: (statuses) => {
-            this._store.setToolStatuses?.(Object.fromEntries(statuses));
+            const hadExecutingTools = this._hasExecutingTools(this._store);
+            this._toolStatuses = statuses;
+            try {
+              this._store.setToolStatuses?.(Object.fromEntries(statuses));
+            } finally {
+              if (hadExecutingTools !== this._hasExecutingTools(this._store)) {
+                if (this._inTrackerUpdate) {
+                  this._pendingRunningRefresh = true;
+                } else {
+                  this._updateStoreSnapshot(this._store);
+                }
+              }
+            }
           },
         },
       );
@@ -431,7 +534,7 @@ export class ExternalStoreThreadRuntimeCore
 
     this._toolInvocations.setState({
       messages: this._messages,
-      isRunning: this._store.isRunning ?? false,
+      isRunning: this._getEffectiveIsRunning(this._store),
       ...(this._store.isLoading !== undefined && {
         isLoading: this._store.isLoading,
       }),
@@ -475,7 +578,7 @@ export class ExternalStoreThreadRuntimeCore
       throw new Error("Runtime does not support switching branches.");
 
     // Silently ignore branch switches while running
-    if (this._store.isRunning) {
+    if (this._getEffectiveIsRunning(this._store)) {
       return;
     }
 
@@ -485,6 +588,7 @@ export class ExternalStoreThreadRuntimeCore
       : null;
 
     this.repository.switchToBranch(branchId);
+    this._pendingDeleteEvictions.clear();
     this.updateMessages(this.repository.getMessages());
     if (onBranchChange) {
       this._notifyBranchChange(previousHeadId, onBranchChange);
@@ -547,7 +651,7 @@ export class ExternalStoreThreadRuntimeCore
       // Buffering does not start a run, so the tool-abort below must wait
       // until the queue flushes. By then the prior run (and its tools) has
       // settled.
-      if (message.steer ?? this._store.isRunning ?? false)
+      if (message.steer ?? this._getEffectiveIsRunning(this._store))
         this._store.queue.steer(message);
       else this._store.queue.enqueue(message);
       return;
@@ -574,6 +678,7 @@ export class ExternalStoreThreadRuntimeCore
     if (isEdit) {
       if (!this._store.onEdit)
         throw new Error("Runtime does not support editing messages.");
+      this._pendingDeleteEvictions.clear();
       await this._store.onEdit(message);
     } else {
       await this._store.onNew(message);
@@ -582,14 +687,29 @@ export class ExternalStoreThreadRuntimeCore
 
   public async deleteMessage(messageId: string): Promise<void> {
     if (this._store.onDelete) {
-      await this._store.onDelete(messageId);
+      // The host owns deletion here, and it may decline (fail a server call,
+      // cancel a confirm dialog, ignore an off-branch id). The eviction is
+      // therefore deferred to the snapshot pass, which evicts only once the
+      // host's own array no longer carries the id. Registered before the
+      // callback because an optimistic host publishes that snapshot while
+      // the callback is still awaited.
+      const wasVisible = this.repository
+        .getMessages()
+        .some((m) => m.id === messageId);
+      if (wasVisible) this._pendingDeleteEvictions.add(messageId);
+      try {
+        await this._store.onDelete(messageId);
+      } catch (error) {
+        this._pendingDeleteEvictions.delete(messageId);
+        throw error;
+      }
       return;
     }
 
     if (!this._store.setMessages)
       throw new Error("Runtime does not support deleting messages.");
 
-    if (this._store.isRunning) {
+    if (this._getEffectiveIsRunning(this._store)) {
       await this._toolInvocations?.abort();
     }
 
@@ -597,7 +717,32 @@ export class ExternalStoreThreadRuntimeCore
     const messageIndex = messages.findIndex((m) => m.id === messageId);
     if (messageIndex === -1) throw new Error("Message not found.");
 
+    this._pendingDeleteEvictions.clear();
     this.updateMessages(messages.filter((message) => message.id !== messageId));
+    this._evictDeletedMessage(messageId);
+  }
+
+  // The snapshot pass only relinks incoming messages; it never evicts, so
+  // without this the deleted message survives as a sibling branch that the
+  // branch picker can resurrect into the host store. `_messages` is refreshed
+  // before notifying so `messages` and the branch graph agree at notify time,
+  // mirroring the end of the snapshot pass.
+  private _evictDeletedMessage(messageId: string) {
+    // Positional fallback ids are remapped in the snapshot pass; evicting
+    // them first leaves the pre-renumber node as a sibling of the new head.
+    if (messageId.startsWith(FALLBACK_ID_PREFIX)) return;
+    // A synchronous host update (e.g. a setMessages that re-entered the
+    // snapshot pass) may have evicted the message already; only that case is
+    // skipped, so genuine repository errors still propagate.
+    try {
+      this.repository.getMessage(messageId);
+    } catch {
+      return;
+    }
+
+    this.repository.deleteMessage(messageId);
+    this._messages = this.repository.getMessages();
+    this._notifySubscribers();
   }
 
   public getQueueItems() {
@@ -622,6 +767,8 @@ export class ExternalStoreThreadRuntimeCore
     if (!this._store.onReload)
       throw new Error("Runtime does not support reloading messages.");
 
+    this._pendingDeleteEvictions.clear();
+
     // Auto-abort in-flight client-side tool executions when a run reloads;
     // any results that land afterward would target a turn that no longer
     // exists. See `append` above for full rationale.
@@ -655,7 +802,7 @@ export class ExternalStoreThreadRuntimeCore
     // back here via __internal_setAdapter. The tracker publishes the
     // cleared status map itself, so adapter-side statuses reset only when
     // the tracker is the source of truth.
-    this._toolInvocations?.reset();
+    this._runTrackerUpdate(() => this._toolInvocations?.reset());
 
     this._store.onLoadExternalState(state);
   }
@@ -666,7 +813,7 @@ export class ExternalStoreThreadRuntimeCore
    * without run-cancel semantics (`onCancel`, composer draft restoration).
    */
   public unstable_notifySessionReset(): void {
-    this._toolInvocations?.reset();
+    this._runTrackerUpdate(() => this._toolInvocations?.reset());
     this._store.queue?.__internal_notifyCancelled?.();
   }
 
@@ -674,6 +821,8 @@ export class ExternalStoreThreadRuntimeCore
     if (!this._store.onCancel)
       throw new Error("Runtime does not support cancelling runs.");
 
+    const generation = captureThreadRuntimeGeneration(this);
+
     // Abort any in-flight client-side tool executions. Fire-and-forget —
     // the abort resolves once executions settle, but we don't gate the
     // cancel on it.
@@ -731,6 +880,8 @@ export class ExternalStoreThreadRuntimeCore
     // tick. Read the repository at flush time and re-apply the rollbacks to
     // it, instead of stamping a snapshot captured above over the newer state.
     setTimeout(() => {
+      if (!isThreadRuntimeGenerationCurrent(this, generation)) return;
+
       this.dropEmptyOptimisticHead();
       if (movedLeaf) {
         const current = this.repository.getMessages();

package/src/runtimes/inert/InertThreadRuntimeCore.test.ts

@@ -0,0 +1,253 @@
+import { describe, expect, it } from "vitest";
+import { BaseSubscribable } from "../../subscribable/subscribable";
+import { ReadonlyThreadRuntimeCore } from "../readonly/ReadonlyThreadRuntimeCore";
+import { EMPTY_THREAD_CORE } from "../remote-thread-list/empty-thread-core";
+
+const READONLY_ERROR = /readonly thread/;
+const EMPTY_ERROR = /empty thread/;
+
+const SHARED_THROWING_METHODS = [
+  "switchToBranch",
+  "append",
+  "deleteMessage",
+  "startRun",
+  "resumeRun",
+  "unstable_notifySessionReset",
+  "addToolResult",
+  "resumeToolCall",
+  "respondToToolApproval",
+  "speak",
+  "connectVoice",
+  "muteVoice",
+  "unmuteVoice",
+  "submitFeedback",
+  "exportExternalState",
+  "importExternalState",
+  "beginEdit",
+  "import",
+  "reset",
+] as const;
+
+const SHARED_THROWING_COMPOSER_METHODS = [
+  "setText",
+  "setRole",
+  "setRunConfig",
+  "send",
+  "startDictation",
+  "setQuote",
+] as const;
+
+const SHARED_NOOP_COMPOSER_METHODS = [
+  "cancel",
+  "stopDictation",
+  "moveQueueItem",
+  "removeQueueItem",
+] as const;
+
+type AnyCore = Record<string, any>;
+
+const cores = [
+  [
+    "ReadonlyThreadRuntimeCore",
+    () => new ReadonlyThreadRuntimeCore() as unknown as AnyCore,
+    READONLY_ERROR,
+  ],
+  [
+    "EMPTY_THREAD_CORE",
+    () => EMPTY_THREAD_CORE as unknown as AnyCore,
+    EMPTY_ERROR,
+  ],
+] as const;
+
+describe.each(cores)("%s shared inert surface", (_name, makeCore, error) => {
+  it.each(SHARED_THROWING_METHODS)("%s throws the core's error", (method) => {
+    expect(() => makeCore()[method]!()).toThrow(error);
+  });
+
+  it.each(SHARED_THROWING_COMPOSER_METHODS)(
+    "composer.%s throws the core's error",
+    (method) => {
+      expect(() => makeCore().composer[method]!()).toThrow(error);
+    },
+  );
+
+  it.each(["addAttachment", "removeAttachment"] as const)(
+    "composer.%s rejects with the core's error",
+    async (method) => {
+      await expect(makeCore().composer[method]!()).rejects.toThrow(error);
+    },
+  );
+
+  it.each(SHARED_NOOP_COMPOSER_METHODS)("composer.%s is a no-op", (method) => {
+    expect(() => makeCore().composer[method]!()).not.toThrow();
+  });
+
+  it("composer.reset and composer.clearAttachments resolve without throwing", async () => {
+    const core = makeCore();
+    await expect(core.composer.reset()).resolves.toBeUndefined();
+    await expect(core.composer.clearAttachments()).resolves.toBeUndefined();
+  });
+
+  it("reports every capability as disabled", () => {
+    expect(makeCore().capabilities).toEqual({
+      switchToBranch: false,
+      switchBranchDuringRun: false,
+      edit: false,
+      delete: false,
+      reload: false,
+      refetchThread: false,
+      cancel: false,
+      unstable_copy: false,
+      speech: false,
+      dictation: false,
+      voice: false,
+      attachments: false,
+      feedback: false,
+      queue: false,
+    });
+  });
+
+  it("exposes inert read-only state", () => {
+    const core = makeCore();
+    expect(core.getModelContext()).toEqual({});
+    expect(core.getEditComposer()).toBeUndefined();
+    expect(core.getVoiceVolume()).toBe(0);
+    expect(core.speech).toBeUndefined();
+    expect(core.voice).toBeUndefined();
+    expect(core.state).toBeNull();
+    expect(core.suggestions).toEqual([]);
+    expect(core.extras).toBeUndefined();
+    expect(core.isDisabled).toBe(false);
+    expect(core.isSendDisabled).toBe(false);
+  });
+
+  it("exposes an empty composer that accepts everything and holds nothing", () => {
+    const composer = makeCore().composer;
+    expect(composer.attachmentAccept).toBe("*");
+    expect(composer.attachments).toEqual([]);
+    expect(composer.text).toBe("");
+    expect(composer.role).toBe("user");
+    expect(composer.runConfig).toEqual({});
+    expect(composer.queue).toEqual([]);
+    expect(composer.dictation).toBeUndefined();
+    expect(composer.quote).toBeUndefined();
+    expect(composer.isEmpty).toBe(true);
+    expect(composer.canSend).toBe(false);
+    expect(composer.canCancel).toBe(false);
+  });
+
+  it("throws one stable error object from every mutator", () => {
+    const core = makeCore();
+    const thrown = SHARED_THROWING_METHODS.map((method) => {
+      try {
+        core[method]!();
+        return undefined;
+      } catch (e) {
+        return e;
+      }
+    });
+
+    expect(thrown[0]).toBeInstanceOf(Error);
+    expect(thrown.every((e) => e === thrown[0])).toBe(true);
+  });
+
+  it("throws a receiver TypeError when a mutator is detached", () => {
+    const detached = makeCore().append!;
+    expect(() => detached()).toThrow(TypeError);
+  });
+
+  it("subscribeVoiceVolume and unstable_on hand back no-op unsubscribers", () => {
+    const core = makeCore();
+    expect(() => core.subscribeVoiceVolume(() => {})()).not.toThrow();
+    expect(() => core.unstable_on("runStart", () => {})()).not.toThrow();
+  });
+});
+
+describe("no-op versus throw divergences", () => {
+  it.each(["cancelRun", "stopSpeaking", "disconnectVoice"] as const)(
+    "%s is a no-op on the readonly core but throws on the empty core",
+    (method) => {
+      const readonly = new ReadonlyThreadRuntimeCore() as unknown as AnyCore;
+      expect(() => readonly[method]!()).not.toThrow();
+      expect(() =>
+        (EMPTY_THREAD_CORE as unknown as AnyCore)[method]!(),
+      ).toThrow(EMPTY_ERROR);
+    },
+  );
+
+  it("readonly is not loading; empty is loading so it is not read as an empty conversation", () => {
+    expect(new ReadonlyThreadRuntimeCore().isLoading).toBe(false);
+    expect(EMPTY_THREAD_CORE.isLoading).toBe(true);
+  });
+
+  it("readonly composer is not editing; empty composer is", () => {
+    expect(new ReadonlyThreadRuntimeCore().composer.isEditing).toBe(false);
+    expect(EMPTY_THREAD_CORE.composer.isEditing).toBe(true);
+  });
+
+  it("the two cores carry distinct error objects and messages", () => {
+    const grab = (fn: () => void) => {
+      try {
+        fn();
+        return undefined;
+      } catch (e) {
+        return e as Error;
+      }
+    };
+
+    const readonlyError = grab(() => new ReadonlyThreadRuntimeCore().append());
+    const emptyError = grab(() =>
+      (EMPTY_THREAD_CORE as unknown as AnyCore).append!(),
+    );
+
+    expect(readonlyError).not.toBe(emptyError);
+    expect(readonlyError?.message).toBe(
+      "This is a readonly thread. You cannot perform mutations on readonly threads.",
+    );
+    expect(emptyError?.message).toMatch(/placeholder for the main thread/);
+  });
+});
+
+describe("readonly notifications", () => {
+  it("notifies subscribers and settles waitForUpdate when messages change", async () => {
+    const core = new ReadonlyThreadRuntimeCore();
+    const seen: number[] = [];
+    const unsubscribe = core.subscribe(() => {
+      seen.push(core.messages.length);
+    });
+    const update = core.waitForUpdate();
+
+    core.setMessages([
+      {
+        id: "m1",
+        role: "user",
+        content: [{ type: "text", text: "hi" }],
+        createdAt: new Date(0),
+        status: { type: "complete", reason: "stop" },
+        metadata: { custom: {} },
+      } as any,
+    ]);
+
+    await expect(update).resolves.toBeUndefined();
+    expect(seen).toEqual([1]);
+    unsubscribe();
+  });
+});
+
+describe("empty singleton", () => {
+  it("does not retain subscribe callbacks", () => {
+    const subscribers = (
+      EMPTY_THREAD_CORE as unknown as Record<string, unknown>
+    )._subscribers as Set<unknown>;
+    const before = subscribers.size;
+    const unsubscribe = EMPTY_THREAD_CORE.subscribe(() => undefined);
+    expect(subscribers.size).toBe(before);
+    expect(() => unsubscribe()).not.toThrow();
+  });
+
+  it("rejects waitForUpdate instead of hanging", async () => {
+    await expect(
+      (EMPTY_THREAD_CORE as unknown as BaseSubscribable).waitForUpdate(),
+    ).rejects.toThrow(EMPTY_ERROR);
+  });
+});