feat(schema-renderer): abort in-flight findAll on cleanup and re-run

SchemaRenderer's `createQuerySignal` and `$single` paths both run
`ModelClass.findAll` inside a `createEffect`.  The effect re-runs on any
reactive dependency change (perspective swap, params token update) and
the component can unmount mid-query.  Without cancellation the stale
findAll keeps grinding through SPARQL serialisation, network round-trip,
and client-side deserialisation — work that's discarded the moment a
fresher result arrives.

Wires an `AbortController` scoped to each effect iteration:

  - `onCleanup` aborts the controller before the effect re-runs or the
    component unmounts.
  - The `findAll(p, queryOptions, { signal })` call forwards the signal
    to ad4m's `Ad4mModel.findAll` (extended in
    coasys/ad4m#855 to thread the signal through
    `modelQuery` → `apiClient.call` → the executor's `request.cancel`
    WebSocket message).
  - `.then` guards on `controller.signal.aborted` to ignore the stale
    result if the controller fired before the promise resolved.
  - `.catch` swallows `DOMException('Aborted', 'AbortError')` so
    cancellation isn't surfaced to the UI as an error — the new effect
    run (or unmount) handles state instead.

The subscribe path already cleans up via `builder.dispose()` and isn't
changed.

Caveat: the executor's Oxigraph SPARQL engine can't be interrupted
mid-evaluation; what's saved is the JSON serialise + WebSocket reply +
client deserialise tax, which dominates for any non-trivial result set.

Tests (queryToken.test.tsx):
- findAll receives an AbortSignal in `options.signal`.
- Unmount aborts the controller.
- Re-running the effect (perspective signal change) aborts the prior
  controller and gives the new run a fresh, un-aborted signal.
- AbortError rejection is swallowed without surfacing.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: HexaField

packages/schema-system/frameworks/solid/src/SchemaRenderer.tsx

@@ -235,9 +235,29 @@ function createQuerySignal(
         });
       onCleanup(() => builder.dispose());
     } else {
-      (ModelClass.findAll(p, queryOptions) as Promise<unknown[]>).then((results) => {
-        setItems(reconcile(normalise(results), { key: 'id', merge: true }));
-      });
+      // The effect re-runs when any reactive dep changes — perspective swap,
+      // resolved params, etc.  When that happens (or the component unmounts)
+      // the previous findAll may still be in flight against a slow query.
+      // An AbortController scoped to this iteration tells the executor to
+      // drop the JSON reply for the stale query instead of paying its
+      // serialise + WebSocket + deserialise cost.
+      //
+      // ad4m's `Ad4mModel.findAll` accepts `options?: { signal?: AbortSignal }`
+      // as the 3rd argument and forwards it through `perspective.modelQuery`
+      // to the executor's `request.cancel` machinery.
+      const controller = new AbortController();
+      onCleanup(() => controller.abort());
+      (ModelClass.findAll(p, queryOptions, { signal: controller.signal }) as Promise<unknown[]>)
+        .then((results) => {
+          if (controller.signal.aborted) return;
+          setItems(reconcile(normalise(results), { key: 'id', merge: true }));
+        })
+        .catch((err) => {
+          // AbortError = a newer effect run or unmount cancelled this query.
+          // Silently drop — no UI state to update, the new run handles it.
+          if (err instanceof DOMException && err.name === 'AbortError') return;
+          throw err;
+        });
     }
   });
 
@@ -557,7 +577,21 @@ export function RenderSchema({ node, stores, registry, context = {}, children }:
             builder.subscribe(handleResults).then(handleResults);
             onCleanup(() => builder.dispose());
           } else {
-            (ModelClass.findAll(p, queryOptions) as Promise<unknown[]>).then(handleResults);
+            // Same abort discipline as the list-path createQuerySignal: the
+            // effect re-runs on perspective swap / param change, and any
+            // in-flight findAll from the previous run should be cancelled so
+            // we don't pay its serialise + transit + deserialise tax.
+            const controller = new AbortController();
+            onCleanup(() => controller.abort());
+            (ModelClass.findAll(p, queryOptions, { signal: controller.signal }) as Promise<unknown[]>)
+              .then((results) => {
+                if (controller.signal.aborted) return;
+                handleResults(results);
+              })
+              .catch((err) => {
+                if (err instanceof DOMException && err.name === 'AbortError') return;
+                throw err;
+              });
           }
         });
       }

packages/schema-system/frameworks/solid/tests/queryToken.test.tsx

@@ -228,6 +228,98 @@ describe('$query token', () => {
     expect(JSON.parse(el?.textContent ?? '[]')).toEqual([{ id: 1 }]);
   });
 
+  // ---- AbortSignal threading + cleanup ----
+
+  it('passes an AbortSignal to findAll and aborts it on unmount', async () => {
+    let capturedSignal: AbortSignal | undefined;
+    const MockModel = {
+      query: vi.fn(),
+      findAll: vi.fn((_p: unknown, _q: unknown, opts: { signal?: AbortSignal } = {}) => {
+        capturedSignal = opts.signal;
+        return Promise.resolve([]);
+      }),
+    };
+    const stores = {
+      spaceStore: { perspective: () => ({ uuid: 'p1' }) },
+      $getModel: () => MockModel,
+    };
+
+    const node: SchemaNode = {
+      type: 'DataDisplay',
+      props: { data: { $query: { model: 'Post', subscribe: false } } },
+    };
+
+    const { unmount } = render(() => <RenderSchema node={node} stores={stores} registry={registry} />);
+    await tick();
+
+    expect(MockModel.findAll).toHaveBeenCalledOnce();
+    expect(capturedSignal).toBeInstanceOf(AbortSignal);
+    expect(capturedSignal!.aborted).toBe(false);
+
+    // Unmount should trigger onCleanup, which aborts the controller.
+    unmount();
+    expect(capturedSignal!.aborted).toBe(true);
+  });
+
+  it('aborts a stale findAll when the effect re-runs', async () => {
+    const signals: AbortSignal[] = [];
+    const MockModel = {
+      query: vi.fn(),
+      findAll: vi.fn((_p: unknown, _q: unknown, opts: { signal?: AbortSignal } = {}) => {
+        if (opts.signal) signals.push(opts.signal);
+        return new Promise<unknown[]>(() => {
+          // Never resolve — simulate slow query
+        });
+      }),
+    };
+    const [perspective, setPerspective] = createSignal<{ uuid: string } | null>({ uuid: 'p1' });
+    const stores = {
+      spaceStore: { perspective },
+      $getModel: () => MockModel,
+    };
+
+    const node: SchemaNode = {
+      type: 'DataDisplay',
+      props: { data: { $query: { model: 'Post', subscribe: false } } },
+    };
+
+    render(() => <RenderSchema node={node} stores={stores} registry={registry} />);
+    await tick();
+    expect(signals.length).toBe(1);
+    expect(signals[0].aborted).toBe(false);
+
+    // Trigger effect re-run by changing the reactive perspective dep.
+    setPerspective({ uuid: 'p2' });
+    await tick();
+
+    // Old run's controller aborted; new run got its own fresh signal.
+    expect(signals[0].aborted).toBe(true);
+    expect(signals.length).toBe(2);
+    expect(signals[1].aborted).toBe(false);
+  });
+
+  it('swallows AbortError from findAll without surfacing it', async () => {
+    const MockModel = {
+      query: vi.fn(),
+      findAll: vi.fn(() => Promise.reject(new DOMException('Aborted', 'AbortError'))),
+    };
+    const stores = {
+      spaceStore: { perspective: () => ({ uuid: 'p1' }) },
+      $getModel: () => MockModel,
+    };
+
+    const node: SchemaNode = {
+      type: 'DataDisplay',
+      props: { data: { $query: { model: 'Post', subscribe: false } } },
+    };
+
+    // If the catch arm doesn't swallow AbortError, the unhandled rejection
+    // would surface as a test failure.
+    render(() => <RenderSchema node={node} stores={stores} registry={registry} />);
+    await tick();
+    expect(MockModel.findAll).toHaveBeenCalledOnce();
+  });
+
   // ---- Query params forwarding ----
 
   it('forwards where/order/limit params to query builder', async () => {