fix(test): bind each render on a mounted test state to its own request signal

A render that receives mountTestState()'s handles rebinds the shared owner
through requestBindings({ signal }) — the generated request scope's own
binding — so aborting one render stops its in-flight state operations
without disturbing the owner the other renders share. Request-lifetime
owners stay as the mount's one binding.

Author: ScriptedAlchemy

packages/agent-bundle/src/test/render.ts

@@ -646,6 +646,25 @@ const noMountedState: AutoMountedState = Object.freeze({
 
 type StateMount = (renderer: Renderer, signal: AbortSignal) => Promise<AutoMountedState>;
 
+/**
+ * Marks the `state` handle a {@link mountTestState} mount hands out. A render
+ * that receives one rebinds the shared owner to its own request signal — the
+ * same `requestBindings({ signal })` a generated request scope performs — so
+ * aborting that render stops its in-flight state operations without
+ * disturbing the owner the other renders share.
+ */
+const MOUNTED_TEST_STATE: unique symbol = Symbol.for('agent-bundle/test-mounted-state');
+
+type RebindMountedState = (signal: AbortSignal) => Promise<AutoMountedState>;
+
+type RebindableStateHandle<
+  TState = unknown,
+  TEvents extends AgentState.AgentStateEventSchemas = AgentState.AgentStateEventSchemas,
+> = AgentState.AgentStateHandle<TState, TEvents> & { readonly [MOUNTED_TEST_STATE]?: RebindMountedState };
+
+const mountedStateRebind = (context: RenderRouteContext): RebindMountedState | undefined =>
+  (context.state as RebindableStateHandle | undefined)?.[MOUNTED_TEST_STATE];
+
 /**
  * Resolves how a manifest render mounts its state, without mounting it: the
  * loader lookup is harness wiring and fails here, while loading the state
@@ -657,6 +676,8 @@ const manifestStateMount = (
   provenance: RenderedRouteProvenance,
   context: RenderRouteContext,
 ): StateMount => {
+  const rebind = mountedStateRebind(context);
+  if (rebind !== undefined) return (_renderer, signal) => rebind(signal);
   const descriptor = manifest?.state;
   if (
     manifest === undefined
@@ -854,9 +875,13 @@ const manifestStateDefinition = async (
  * removes; every other lifetime uses the memory driver. `renderRoute` and
  * `renderRouteEvents` honour a caller-supplied `state` and `noticeLedger`, so
  * spreading `context()` into each render's `context` is the whole wiring; a
- * render that omits them still mounts its own isolated owner. The owner is
- * held as one request's bindings, so a `request`-lifetime definition behaves
- * as one long request. Always `close()` it (or use {@link withTestState}).
+ * render that omits them still mounts its own isolated owner. Each render
+ * that receives the handles binds the shared owner to its own request
+ * signal, exactly as a generated request scope does, so a render's `signal`
+ * still cancels its state operations; `read()`, `notices()`, and the handles
+ * themselves are bound to `options.signal`. The owner is held as one request's
+ * bindings, so a `request`-lifetime definition behaves as one long request.
+ * Always `close()` it (or use {@link withTestState}).
  */
 export const mountTestState = async <
   TState = unknown,
@@ -877,11 +902,30 @@ export const mountTestState = async <
     await opened.dispose();
     throw error;
   }
+  let closed = false;
+  // A render that receives these handles rebinds the shared owner to its own
+  // request signal (see MOUNTED_TEST_STATE). A `request`-lifetime owner opens
+  // fresh stores per binding, so it is not rebound: the mount's one binding
+  // is the request every render shares.
+  const rebind: RebindMountedState = async (signal) => {
+    if (closed || definition.lifetime === 'request') return noMountedState;
+    const request = await opened.owner.requestBindings({ signal });
+    return Object.freeze({
+      context: { noticeLedger: request.noticeLedger, state: request.state },
+      close: request.close,
+    });
+  };
+  const state: RebindableStateHandle<TState, TEvents> = Object.freeze({
+    lifetime: bindings.state.lifetime,
+    changes: bindings.state.changes,
+    dispatch: bindings.state.dispatch,
+    read: bindings.state.read,
+    [MOUNTED_TEST_STATE]: rebind,
+  });
   const context: MountedTestStateContext<TState, TEvents> = Object.freeze({
     noticeLedger: bindings.noticeLedger,
-    state: bindings.state,
+    state,
   });
-  let closed = false;
   return Object.freeze({
     ...context,
     async close() {

packages/agent-bundle/tests/route-unit/mount-test-state.test.ts

@@ -56,6 +56,44 @@ describe('mountTestState', () => {
     }
   });
 
+  it('binds each render to its own signal without disturbing the shared owner', async () => {
+    const mounted = await mountTestState<JournalState>();
+    try {
+      await renderRoute('tool:harness/journal', { context: mounted.context(), input: { note: 'kept' } });
+
+      // A cancelled render neither commits nor closes the owner the other renders share.
+      const cancelled = new AbortController();
+      cancelled.abort();
+      await expect(renderRoute('tool:harness/journal', {
+        context: mounted.context(),
+        input: { note: 'never' },
+        signal: cancelled.signal,
+      })).rejects.toThrow();
+      expect((await mounted.read()).state.entries).toEqual([{ note: 'kept' }]);
+
+      // The handle a render receives is the owner rebound to that render's
+      // signal — the request scope's own binding — not the mount-wide one.
+      const rebind = (mounted.state as unknown as Record<symbol, (signal: AbortSignal) => Promise<{
+        readonly context: { readonly state: { read(): Promise<unknown> } };
+        close(): Promise<void>;
+      }>>)[Symbol.for('agent-bundle/test-mounted-state')]!;
+      const aborted = new AbortController();
+      aborted.abort(new Error('render cancelled'));
+      const bound = await rebind(aborted.signal);
+      try {
+        await expect(bound.context.state.read()).rejects.toThrow();
+        await expect(mounted.read()).resolves.toMatchObject({ state: { entries: [{ note: 'kept' }] } });
+      } finally {
+        await bound.close();
+      }
+
+      const after = await renderRoute('tool:harness/journal', { context: mounted.context(), input: { note: 'after' } });
+      expectDocument(after).toHaveValue({ entries: [{ note: 'kept' }, { note: 'after' }], revision: 2 });
+    } finally {
+      await mounted.close();
+    }
+  });
+
   it('closes idempotently, after which the handles are closed too', async () => {
     const mounted = await mountTestState();
     const rendered = await renderRoute('tool:harness/journal', { context: mounted.context(), input: { note: 'x' } });

website/docs/en/guide/development/testing.mdx

@@ -170,7 +170,9 @@ try {
 ```
 
 `read()` and `notices()` are the owner's own snapshots, not a per-render copy; `state` and
-`noticeLedger` are exposed too, for a direct `dispatch`. `withTestState(async (state) => { ... })`
+`noticeLedger` are exposed too, for a direct `dispatch`. Each render binds the shared owner to its
+own request signal, exactly as a generated request scope does, so a render's `signal` still
+cancels that render's state operations. `withTestState(async (state) => { ... })`
 is the same mount scoped to one callback, closed when it settles. The snapshot type comes from the
 type arguments — the state registration carries no state type — or, checked, from
 `options.definition`, which mounts that definition instead of the manifest's (an `external`

website/docs/zh/guide/development/testing.mdx

@@ -147,7 +147,8 @@ try {
 ```
 
 `read()` 与 `notices()` 是所有者自身的快照，而不是每次渲染的副本；`state` 与 `noticeLedger` 也会暴露出来，
-以便直接 `dispatch`。`withTestState(async (state) => { ... })` 是同一次挂载限定在一个回调内的形式，回调
+以便直接 `dispatch`。每次渲染都会把共享的所有者绑定到它自己的请求信号上——与生成的请求作用域完全一致——
+因此某次渲染的 `signal` 仍然会取消该次渲染的 state 操作。`withTestState(async (state) => { ... })` 是同一次挂载限定在一个回调内的形式，回调
 结束时关闭。快照类型来自类型参数——state 注册不携带 state 类型——或者（经过检查地）来自
 `options.definition`，它会挂载该定义而不是 manifest 的定义（`external` 定义需要 `options.driver`，
 因为它没有指名任何测试工具能打开的存储）。省略了已挂载句柄的渲染仍会获得自己隔离的所有者，因此两种写法