@assistant-ui/core 0.3.19 → 0.3.21

package/src/react/client/RemoteThreadList.ts

@@ -876,6 +876,12 @@ const useRemoteThreadList = (
       }
       let lastAwaitedTask: Promise<void> | undefined;
       while (isSameThread(store.value, threadId, session.mainThreadId)) {
+        // Rechecked each pass: the draft can become the new thread again
+        // mid-loop when its failed first save rolls it back, and switching to
+        // a new thread then re-adopts it, so no switch can move main off it.
+        if (threadId === store.value.newThreadId) {
+          throw new Error("Cannot ensure new thread is not main");
+        }
         let switchTask = session.switchTask;
         const startedFallback = !switchTask || switchTask === lastAwaitedTask;
         if (startedFallback) {

package/src/react/client/Tools.ts

@@ -22,6 +22,7 @@ import {
 import type { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
 import { ModelContext } from "../../store/clients/model-context-client";
 import { nullProtoRecord } from "../../utils/record";
+import { runCleanups } from "../../subscribable/subscribable";
 
 export type { McpAppResourceOutput };
 
@@ -127,9 +128,7 @@ const useTools = ({
       }
     }
 
-    return () => {
-      unsubscribes.forEach((fn) => fn());
-    };
+    return () => runCleanups(unsubscribes);
   }, [toolkit, setToolUI]);
 
   useAssistantScopeEffect(

package/src/react/client/interactable-model-context.test.ts

@@ -9,7 +9,7 @@ vi.mock("../../utils/id", async (importOriginal) => ({
 
 import {
   buildInteractableModelContext,
-  type PartialJSONSchema,
+  type StateJSONSchema,
 } from "./interactable-model-context";
 import type { Unstable_InteractableDefinition } from "../types/scopes/interactables";
 
@@ -26,12 +26,13 @@ const def = (
   initialState: state,
 });
 
-const partialNoteSchema = {
+const noteSchema = {
   type: "object" as const,
   properties: { title: { type: "string" as const } },
+  required: ["title"],
 };
 
-const partialTaskBoardSchema = {
+const taskBoardSchema = {
   type: "object" as const,
   properties: {
     tasks: {
@@ -51,15 +52,23 @@ const partialTaskBoardSchema = {
 
 const build = (
   definitions: Record<string, Unstable_InteractableDefinition>,
-  cache: Map<string, PartialJSONSchema> = new Map([["n1", partialNoteSchema]]),
+  cache: Map<string, StateJSONSchema> = new Map([["n1", noteSchema]]),
+  // The tool is built from a snapshot, so a caller can pass a separate map to
+  // model what the runtime holds by the time the call arrives.
+  live: Record<string, Unstable_InteractableDefinition> = definitions,
 ) => {
   const setDefState = vi.fn(
     (id: string, updater: (prev: unknown) => unknown) => {
-      const d = definitions[id];
-      if (d) definitions[id] = { ...d, state: updater(d.state) };
+      const d = live[id];
+      if (d) live[id] = { ...d, state: updater(d.state) };
     },
   );
-  const ctx = buildInteractableModelContext(definitions, cache, setDefState);
+  const ctx = buildInteractableModelContext(
+    definitions,
+    cache,
+    setDefState,
+    () => live,
+  );
   return { ctx, setDefState };
 };
 
@@ -86,7 +95,7 @@ describe("buildInteractableModelContext", () => {
     ]);
   });
 
-  it("wraps the partial schema with a required id parameter", () => {
+  it("replaces the root required list with the id parameter", () => {
     const { ctx } = build({ n1: def("n1", "note") });
     const params = ctx!.tools["update_note"]!.parameters as {
       properties: Record<string, unknown>;
@@ -148,7 +157,7 @@ describe("buildInteractableModelContext", () => {
   it("exposes operation schemas for array fields", () => {
     const { ctx } = build(
       { b1: def("b1", "taskBoard") },
-      new Map([["b1", partialTaskBoardSchema]]),
+      new Map([["b1", taskBoardSchema]]),
     );
     const params = ctx!.tools["update_taskBoard"]!.parameters as {
       properties: {
@@ -171,7 +180,7 @@ describe("buildInteractableModelContext", () => {
   it("omits id from add items but keeps it for update", () => {
     const { ctx } = build(
       { b1: def("b1", "taskBoard") },
-      new Map([["b1", partialTaskBoardSchema]]),
+      new Map([["b1", taskBoardSchema]]),
     );
     const tasks = (
       ctx!.tools["update_taskBoard"]!.parameters as {
@@ -220,7 +229,7 @@ describe("buildInteractableModelContext", () => {
 
     it("mints an id for an added item that has none", async () => {
       const defs = { b1: def("b1", "taskBoard", { tasks: [] }) };
-      const { ctx } = build(defs, new Map([["b1", partialTaskBoardSchema]]));
+      const { ctx } = build(defs, new Map([["b1", taskBoardSchema]]));
       const result = await ctx!.tools["update_taskBoard"]!.execute!(
         { id: "b1", tasks: { add: [{ title: "Write tests", done: false }] } },
         {} as never,
@@ -298,6 +307,40 @@ describe("buildInteractableModelContext", () => {
       expect(setDefState).not.toHaveBeenCalled();
     });
 
+    it("rejects a target that unmounted after the tool was built", async () => {
+      const built = { n1: def("n1", "note"), n2: def("n2", "note") };
+      const live: Record<string, Unstable_InteractableDefinition> = {
+        n2: def("n2", "note"),
+      };
+      const { ctx, setDefState } = build(built, undefined, live);
+
+      const result = (await ctx!.tools["update_note"]!.execute!(
+        { id: "n1", title: "B" },
+        {} as never,
+      )) as { success: boolean; error?: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Valid ids: n2");
+      expect(setDefState).not.toHaveBeenCalled();
+    });
+
+    it("rejects a same-id replacement registered under another name", async () => {
+      const built = { n1: def("n1", "note", { title: "A" }) };
+      const live: Record<string, Unstable_InteractableDefinition> = {
+        n1: def("n1", "board", { title: "replacement" }),
+      };
+      const { ctx, setDefState } = build(built, undefined, live);
+
+      const result = (await ctx!.tools["update_note"]!.execute!(
+        { id: "n1", title: "B" },
+        {} as never,
+      )) as { success: boolean; error?: string };
+
+      expect(result.success).toBe(false);
+      expect(setDefState).not.toHaveBeenCalled();
+      expect(live["n1"]!.state).toEqual({ title: "replacement" });
+    });
+
     it("rejects an id-less call when multiple instances exist", async () => {
       const defs = { n1: def("n1", "note"), n2: def("n2", "note") };
       const { ctx, setDefState } = build(defs);
@@ -328,7 +371,7 @@ describe("buildInteractableModelContext", () => {
           ],
         }),
       };
-      const { ctx } = build(defs, new Map([["b1", partialTaskBoardSchema]]));
+      const { ctx } = build(defs, new Map([["b1", taskBoardSchema]]));
 
       await ctx!.tools["update_taskBoard"]!.execute!(
         {
@@ -422,7 +465,7 @@ describe("buildInteractableModelContext", () => {
           tasks: [{ id: "a", title: "A", done: false }],
         }),
       };
-      const { ctx } = build(defs, new Map([["b1", partialTaskBoardSchema]]));
+      const { ctx } = build(defs, new Map([["b1", taskBoardSchema]]));
       const context = { toolCallId: "call-1" } as never;
 
       await ctx!.tools["update_taskBoard"]!.streamCall!(

package/src/react/client/interactable-model-context.ts

@@ -1,5 +1,6 @@
 import type { Tool } from "assistant-stream";
 import { toJSONSchema } from "assistant-stream";
+import { getPartialJsonObjectMeta } from "assistant-stream/utils";
 import type { Unstable_InteractableDefinition } from "../types/scopes/interactables";
 import {
   interactableToolName,
@@ -10,7 +11,7 @@ import { generateId } from "../../utils/id";
 import { isRecord } from "../../utils/json/is-json";
 import { nullProtoRecord } from "../../utils/record";
 
-export type PartialJSONSchema = ReturnType<typeof toJSONSchema>;
+export type StateJSONSchema = ReturnType<typeof toJSONSchema>;
 
 const ID_PROPERTY = {
   type: "string" as const,
@@ -110,12 +111,13 @@ const withArrayUpdateSchemas = (properties: Record<string, unknown>) =>
   );
 
 /**
- * Wraps an interactable's partial state schema with the required `id`
- * parameter. Falls back to a permissive schema when the partial conversion
- * failed at registration time.
+ * Replaces the state schema's root `required` list with the `id` parameter,
+ * so every top-level field is optional while nested objects keep theirs and
+ * travel whole through the shallow merge. Falls back to a permissive schema
+ * when the JSON Schema conversion failed at registration time.
  */
-function withRequiredId(partial: PartialJSONSchema | undefined) {
-  if (!partial || typeof partial !== "object" || partial.type !== "object") {
+function withRequiredId(schema: StateJSONSchema | undefined) {
+  if (!schema || typeof schema !== "object" || schema.type !== "object") {
     return {
       type: "object" as const,
       properties: { id: ID_PROPERTY },
@@ -123,16 +125,16 @@ function withRequiredId(partial: PartialJSONSchema | undefined) {
       additionalProperties: true,
     };
   }
-  if (process.env.NODE_ENV !== "production" && partial.properties?.id) {
+  if (process.env.NODE_ENV !== "production" && schema.properties?.id) {
     console.warn(
       `[Interactables] a top-level "id" field in an interactable's stateSchema is ` +
         `reserved for instance addressing by the update tool and cannot be updated ` +
         `by the model. Rename the field to make it model-writable.`,
     );
   }
-  const { id: _reserved, ...properties } = partial.properties ?? {};
+  const { id: _reserved, ...properties } = schema.properties ?? {};
   return {
-    ...partial,
+    ...schema,
     properties: { id: ID_PROPERTY, ...withArrayUpdateSchemas(properties) },
     required: ["id"],
   };
@@ -140,8 +142,9 @@ function withRequiredId(partial: PartialJSONSchema | undefined) {
 
 export function buildInteractableModelContext(
   definitions: Record<string, Unstable_InteractableDefinition>,
-  partialSchemaCache: Map<string, PartialJSONSchema>,
+  schemaCache: Map<string, StateJSONSchema>,
   setDefState: (id: string, updater: (prev: unknown) => unknown) => void,
+  getCurrentDefinitions: () => Record<string, Unstable_InteractableDefinition>,
   streamBaselines = new Map<string, { targetId: string; state: unknown }>(),
 ):
   | {
@@ -174,10 +177,10 @@ export function buildInteractableModelContext(
     }
 
     const first = instances[0]!;
-    const partialSchema = partialSchemaCache.get(first.id);
+    const jsonSchema = schemaCache.get(first.id);
     const idKeyedFields =
-      partialSchema && isRecord(partialSchema.properties)
-        ? idKeyedArrayFieldNames(partialSchema.properties)
+      jsonSchema && isRecord(jsonSchema.properties)
+        ? idKeyedArrayFieldNames(jsonSchema.properties)
         : new Set<string>();
 
     // `id` resolves to a definition of this name; an id-less call is accepted
@@ -198,8 +201,9 @@ export function buildInteractableModelContext(
         `Update the state of interactable component "${name}". ${first.description} ` +
         `Pass the id of the instance to update — instance ids and current state ` +
         `appear in the conversation as state snapshots. Only include the fields ` +
-        `you want to change; omitted fields keep their current values.`,
-      parameters: withRequiredId(partialSchema),
+        `you want to change; omitted fields keep their current values. A nested ` +
+        `object replaces the existing one, so send it complete.`,
+      parameters: withRequiredId(jsonSchema),
       streamCall: async (reader, { toolCallId }) => {
         try {
           for await (const partialArgs of reader.args.streamValues()) {
@@ -213,19 +217,29 @@ export function buildInteractableModelContext(
             if (Object.keys(partial).length === 0) continue;
             const target = resolveTarget(id);
             if (!target) continue;
+            const currentTarget = getCurrentDefinitions()[target.id];
+            if (currentTarget?.name !== name) continue;
 
             const baseline = streamBaselines.get(toolCallId);
             const arrayBaseline =
-              baseline?.targetId === target.id ? baseline.state : target.state;
+              baseline?.targetId === target.id
+                ? baseline.state
+                : currentTarget.state;
             if (!baseline || baseline.targetId !== target.id) {
               streamBaselines.set(toolCallId, {
                 targetId: target.id,
-                state: target.state,
+                state: currentTarget.state,
               });
             }
 
+            const partialPath = getPartialJsonObjectMeta(
+              args as Record<symbol, unknown>,
+            )?.partialPath;
             setDefState(target.id, (prev) =>
-              shallowMergeInteractableState(prev, partial, { arrayBaseline }),
+              shallowMergeInteractableState(prev, partial, {
+                arrayBaseline,
+                partialPath,
+              }),
             );
           }
         } catch {
@@ -235,8 +249,17 @@ export function buildInteractableModelContext(
       execute: async (args: unknown, { toolCallId }) => {
         const { id, ...partial } = (args ?? {}) as Record<string, unknown>;
         const target = resolveTarget(id);
-        if (!target) {
-          const validIds = instances.map((d) => d.id);
+        // The tool was built from a snapshot, so the target may have unmounted
+        // or been replaced under the same id since; mutating either would
+        // report success for a write nothing receives.
+        const currentDefinitions = getCurrentDefinitions();
+        const currentTarget = target
+          ? currentDefinitions[target.id]
+          : undefined;
+        if (!currentTarget || currentTarget.name !== name) {
+          const validIds = Object.values(currentDefinitions)
+            .filter((def) => def.name === name)
+            .map((def) => def.id);
           return {
             success: false,
             error: `Unknown id ${JSON.stringify(id)} for interactable "${name}". Valid ids: ${validIds.join(", ")}`,
@@ -245,10 +268,12 @@ export function buildInteractableModelContext(
         const baseline = streamBaselines.get(toolCallId);
         streamBaselines.delete(toolCallId);
         const addedItemIds = nullProtoRecord<string[]>();
-        setDefState(target.id, (prev) =>
+        setDefState(currentTarget.id, (prev) =>
           shallowMergeInteractableState(prev, partial, {
             arrayBaseline:
-              baseline?.targetId === target.id ? baseline.state : undefined,
+              baseline?.targetId === currentTarget.id
+                ? baseline.state
+                : undefined,
             idFactory: (field) => {
               const itemId = generateId();
               (addedItemIds[field] ??= []).push(itemId);
@@ -263,7 +288,7 @@ export function buildInteractableModelContext(
           success: true;
           id: string;
           addedItemIds?: Record<string, string[]>;
-        } = { success: true, id: target.id };
+        } = { success: true, id: currentTarget.id };
         if (Object.keys(addedItemIds).length > 0) {
           result.addedItemIds = { ...addedItemIds };
         }

package/src/react/index.ts

@@ -1,5 +1,5 @@
-/// <reference path="../store/scope-registration.ts" />
-/// <reference path="./types/store-augmentation.ts" />
+/// <reference path="../store/scope-registration.ts" preserve="true" />
+/// <reference path="./types/store-augmentation.ts" preserve="true" />
 
 // model-context
 export {

package/src/react/interactables-legacy/Interactables.test.ts

@@ -1,6 +1,9 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { createTapRoot, flushTapSync, useResource } from "@assistant-ui/tap";
+import { parsePartialJsonObject } from "assistant-stream/utils";
+import { z } from "zod";
 import type {
+  InteractablePersistedState,
   InteractablePersistenceAdapter,
   InteractableRegistration,
 } from "./scopes";
@@ -8,7 +11,12 @@ import type {
 const clientHolder: { client: unknown } = { client: null };
 const clientListeners = new Set<() => void>();
 let registeredModelContextProvider:
-  | { subscribe?: (callback: () => void) => () => void }
+  | {
+      getModelContext?: () => {
+        tools?: Record<string, { parameters?: unknown }>;
+      };
+      subscribe?: (callback: () => void) => () => void;
+    }
   | undefined;
 
 vi.mock("@assistant-ui/store", async (importOriginal) => {
@@ -89,7 +97,10 @@ const reg = (id: string): InteractableRegistration => ({
   id,
   name: "note",
   description: "a note",
-  stateSchema: { type: "object", properties: {} } as never,
+  stateSchema: {
+    type: "object",
+    properties: {},
+  } satisfies InteractableRegistration["stateSchema"],
   initialState: { v: 0 },
 });
 
@@ -110,6 +121,139 @@ afterEach(() => {
   vi.restoreAllMocks();
 });
 
+describe("legacy Interactables update tool", () => {
+  it("relaxes only the root requirement of the update tool", async () => {
+    const stateSchema = z.object({
+      title: z.string(),
+      settings: z.object({ name: z.string(), size: z.number() }),
+    });
+    root = mount();
+    await flushMicrotasks();
+    root.getValue().register({
+      ...reg("n1"),
+      stateSchema,
+      initialState: { title: "old", settings: { name: "n", size: 1 } },
+    });
+
+    const tool = registeredModelContextProvider?.getModelContext?.().tools
+      ?.update_note as
+      | {
+          parameters: {
+            required?: string[];
+            properties: { settings: { required?: string[] } };
+          };
+          execute(
+            args: Record<string, unknown>,
+            context: { toolCallId: string },
+          ): Promise<unknown>;
+        }
+      | undefined;
+    expect(tool).toBeDefined();
+    const { parameters } = tool!;
+    expect("~standard" in parameters).toBe(false);
+    expect(parameters.required).toBeUndefined();
+    expect(parameters.properties.settings.required).toEqual(["name", "size"]);
+
+    await tool!.execute({ title: "new" }, { toolCallId: "call-1" });
+    await tool!.execute(
+      { settings: { name: "new", size: 2 } },
+      { toolCallId: "call-2" },
+    );
+    await flushMicrotasks();
+    expect(
+      stateSchema.parse(root.getValue().getState().definitions["n1"]?.state),
+    ).toEqual({ title: "new", settings: { name: "new", size: 2 } });
+  });
+
+  it("keeps a streaming nested object parseable at every token", async () => {
+    const stateSchema = z.object({
+      title: z.string(),
+      settings: z.object({ name: z.string(), size: z.number() }),
+    });
+    root = mount();
+    await flushMicrotasks();
+    root.getValue().register({
+      ...reg("n1"),
+      stateSchema,
+      initialState: { title: "old", settings: { name: "n", size: 1 } },
+    });
+
+    const tool = registeredModelContextProvider?.getModelContext?.().tools
+      ?.update_note as
+      | {
+          streamCall(reader: {
+            args: { streamValues(): AsyncIterable<unknown> };
+          }): Promise<unknown>;
+          execute(
+            args: Record<string, unknown>,
+            context: { toolCallId: string },
+          ): Promise<unknown>;
+        }
+      | undefined;
+    expect(tool).toBeDefined();
+
+    const text = '{"settings":{"name":"medium","size":2}}';
+    const ticks: { prefix: string; state: unknown }[] = [];
+    await tool!.streamCall({
+      args: {
+        async *streamValues() {
+          for (let end = 1; end <= text.length; end++) {
+            const parsed = parsePartialJsonObject(text.slice(0, end));
+            if (!parsed) continue;
+            yield parsed;
+            await flushMicrotasks();
+            ticks.push({
+              prefix: text.slice(0, end),
+              state: root!.getValue().getState().definitions["n1"]?.state,
+            });
+          }
+        },
+      },
+    });
+    for (const { prefix, state } of ticks) {
+      expect(stateSchema.safeParse(state).success, prefix).toBe(true);
+    }
+    const distinct = ticks
+      .map(({ state }) => JSON.stringify(state))
+      .filter((state, index, all) => state !== all[index - 1])
+      .map((state) => JSON.parse(state));
+    expect(distinct).toEqual(
+      ["n", "", "m", "me", "med", "medi", "mediu", "medium"]
+        .map((name) => ({ title: "old", settings: { name, size: 1 } }))
+        .concat({ title: "old", settings: { name: "medium", size: 2 } }),
+    );
+
+    await tool!.execute(JSON.parse(text), { toolCallId: "call-1" });
+    await flushMicrotasks();
+    expect(
+      stateSchema.parse(root.getValue().getState().definitions["n1"]?.state),
+    ).toEqual({ title: "old", settings: { name: "medium", size: 2 } });
+  });
+
+  it("falls back to the raw schema when a re-registration cannot convert", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const unconvertible = {
+      "~standard": {
+        version: 1 as const,
+        vendor: "zod",
+        validate: () => ({ value: {} }),
+      },
+    };
+    root = mount();
+    await flushMicrotasks();
+    root
+      .getValue()
+      .register({ ...reg("n1"), stateSchema: z.object({ v: z.number() }) });
+    root.getValue().register({ ...reg("n1"), stateSchema: unconvertible });
+
+    expect(
+      registeredModelContextProvider?.getModelContext?.().tools?.update_note
+        ?.parameters,
+    ).toBe(unconvertible);
+    expect(warn).toHaveBeenCalledOnce();
+  });
+});
+
 describe("legacy Interactables persistence", () => {
   it("notifies every model-context subscriber when one throws", async () => {
     root = mount();
@@ -152,9 +296,24 @@ describe("legacy Interactables persistence", () => {
     expect(secondSave).not.toHaveBeenCalled();
   });
 
+  it("does not retain edits made before an adapter attaches", async () => {
+    const save = vi.fn();
+    root = mount();
+    await flushMicrotasks();
+    root.getValue().register(reg("n1"));
+    root.getValue().setState("n1", () => ({ v: 1 }));
+
+    root.getValue().setPersistenceAdapter({ save });
+    await root.getValue().flush();
+
+    expect(save).not.toHaveBeenCalled();
+  });
+
   it("keeps edits queued during an in-flight flush with the outgoing adapter", async () => {
     const saveResolvers: Array<() => void> = [];
-    const firstSave = vi.fn(
+    const firstSave = vi.fn<
+      (state: InteractablePersistedState) => Promise<void>
+    >(
       () =>
         new Promise<void>((resolve) => {
           saveResolvers.push(resolve);
@@ -177,7 +336,7 @@ describe("legacy Interactables persistence", () => {
     saveResolvers[0]!();
     await flushMicrotasks();
     expect(firstSave).toHaveBeenCalledTimes(2);
-    expect(firstSave.mock.calls[1]![0]).toEqual({
+    expect(firstSave.mock.calls[1]?.[0]).toEqual({
       n1: { name: "note", state: { v: 2 } },
     });
     expect(firstSave.mock.calls.at(-1)?.[0]).toEqual({
@@ -283,6 +442,64 @@ describe("legacy Interactables persistence", () => {
     expect(root.getValue().getState().persistence["n1"]).toBeUndefined();
   });
 
+  it("does not publish a previous adapter's failure into the new adapter's scope", async () => {
+    let rejectFirstSave!: (reason: unknown) => void;
+    const firstSave = vi.fn(
+      () =>
+        new Promise<void>((_resolve, reject) => {
+          rejectFirstSave = reject;
+        }),
+    );
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    root = mount();
+    await flushMicrotasks();
+    root.getValue().setPersistenceAdapter({ save: firstSave });
+    root.getValue().register(reg("n1"));
+
+    root.getValue().setState("n1", () => ({ v: 1 }));
+    await vi.advanceTimersByTimeAsync(500);
+    root.getValue().setPersistenceAdapter({ save: vi.fn() });
+    await flushMicrotasks();
+
+    rejectFirstSave(new Error("stale adapter save failed"));
+    await flushMicrotasks();
+
+    expect(root.getValue().getState().persistence["n1"]?.error).toBeUndefined();
+    expect(warn).toHaveBeenCalledWith(
+      "[Interactables] Persistence save failed after the adapter changed.",
+      expect.any(Error),
+    );
+    warn.mockRestore();
+  });
+
+  it("keeps an in-flight save failure in the same scope across a detach and reattach", async () => {
+    let rejectSave!: (reason: unknown) => void;
+    const save = vi.fn(
+      () =>
+        new Promise<void>((_resolve, reject) => {
+          rejectSave = reject;
+        }),
+    );
+    const adapter: InteractablePersistenceAdapter = { save };
+    root = mount();
+    await flushMicrotasks();
+    root.getValue().setPersistenceAdapter(adapter);
+    root.getValue().register(reg("n1"));
+
+    root.getValue().setState("n1", () => ({ v: 1 }));
+    await vi.advanceTimersByTimeAsync(500);
+    root.getValue().setPersistenceAdapter(undefined);
+    root.getValue().setPersistenceAdapter(adapter);
+    await flushMicrotasks();
+
+    rejectSave(new Error("same scope save failed"));
+    await flushMicrotasks();
+
+    expect(root.getValue().getState().persistence["n1"]?.error).toBeInstanceOf(
+      Error,
+    );
+  });
+
   it("keeps an interactable pending while its newer edit is queued", async () => {
     const saveResolvers: Array<() => void> = [];
     const firstSave = vi.fn(