@cosmicdrift/kumiko-renderer 0.327.0 → 0.328.1

package/src/components/write-form-section.tsx

@@ -1,199 +0,0 @@
-import type {
-  EditFieldViewModel,
-  EditWriteFormSectionViewModel,
-  Translate,
-} from "@cosmicdrift/kumiko-headless";
-import { I18N_KEY_PARAM } from "@cosmicdrift/kumiko-headless";
-import { type ReactNode, useMemo, useState } from "react";
-import * as z from "zod";
-import { REQUIRED_FIELD_I18N_KEY } from "../app/form-schema";
-import { dispatcherErrorText } from "../app/write-failed-error";
-import { useForm } from "../hooks/use-form";
-import { useTranslation } from "../i18n";
-import { usePrimitives } from "../primitives";
-import { GridCellForField } from "./grid-cell-for-field";
-
-// Same "has a value" rule as buildFormSchema's isPresent (app/form-schema.ts)
-// — duplicated because that helper walks raw EditFieldSpec + EntityDefinition,
-// unavailable here: this section only ever sees computeEditViewModel's
-// already-resolved EditFieldViewModel[] (required/readOnly/visible are plain
-// booleans by the time render-edit.tsx hands the section to this component).
-function isPresent(value: unknown): boolean {
-  if (value === undefined || value === null || value === "") return false;
-  if (Array.isArray(value) && value.length === 0) return false;
-  return true;
-}
-
-function buildWriteFormSchema(fields: readonly EditFieldViewModel[]): z.ZodType {
-  return z
-    .object({})
-    .passthrough()
-    .superRefine((values, ctx) => {
-      const record = values as Record<string, unknown>;
-      for (const field of fields) {
-        if (field.readOnly || !field.visible || !field.required) continue;
-        if (isPresent(record[field.field])) continue;
-        ctx.addIssue({
-          code: "custom",
-          path: [field.field],
-          message: `"${field.field}" is required.`,
-          params: { [I18N_KEY_PARAM]: REQUIRED_FIELD_I18N_KEY },
-        });
-      }
-    });
-}
-
-export type WriteFormSectionProps = {
-  readonly section: EditWriteFormSectionViewModel;
-  readonly featureName: string;
-  readonly translate?: Translate;
-  readonly hideTitle?: boolean;
-  /** Fired after a successful submit — projectionDetail reloads its own
-   *  record (a new one now exists) via a full RenderEdit remount, see
-   *  ProjectionDetailBody's reloadNonce/key in kumiko-screen.tsx. */
-  readonly onSubmitted: () => void;
-  /** section.actions, already resolved into buttons by the caller —
-   *  rendered alongside (before) the section's own submit button in the
-   *  title-row actions slot. */
-  readonly actions?: ReactNode;
-};
-
-// A self-persisting form section for projectionDetail (see
-// EditWriteFormSection's doc). Deliberately NOT a nested <RenderEdit> — that
-// would render a second, invalid nested <form> inside the host's own form
-// element — so this mounts its own independent useForm() controller and
-// submits via a plain button click instead of native form submission.
-export function WriteFormSection({
-  section,
-  featureName,
-  translate,
-  hideTitle,
-  onSubmitted,
-  actions,
-}: WriteFormSectionProps): ReactNode {
-  const { Section, Card, Grid, GridCell, Button, Banner } = usePrimitives();
-  const t = useTranslation();
-  const effectiveTranslate = translate ?? t;
-
-  const initial = useMemo(
-    () => Object.fromEntries(section.fields.map((f: EditFieldViewModel) => [f.field, f.value])),
-    [section.fields],
-  );
-  const schema = useMemo(() => buildWriteFormSchema(section.fields), [section.fields]);
-  const { controller, snapshot } = useForm({
-    initial,
-    submit: { type: section.handler, payloadMode: "values" },
-    schema,
-  });
-  const [isSubmitting, setIsSubmitting] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  async function handleSubmit(): Promise<void> {
-    if (isSubmitting) return;
-    setIsSubmitting(true);
-    try {
-      const result = await controller.submit();
-      if (result.isSuccess) {
-        setError(null);
-        onSubmitted();
-        return;
-      }
-      if (result.validationBlocked) return;
-      // Field-level issues already surface inline via snapshot.errors (same
-      // GridCellForField/RenderField path RenderEdit uses) — the banner is
-      // only for form-level errors nothing else would show (fw#1901 pattern).
-      const fieldIssues = result.error.details?.fields ?? [];
-      setError(
-        fieldIssues.length === 0 ? dispatcherErrorText(result.error, effectiveTranslate) : null,
-      );
-    } finally {
-      setIsSubmitting(false);
-    }
-  }
-
-  const content = (
-    <>
-      <Grid columns={section.columns}>
-        {section.fields.map((field: EditFieldViewModel) => (
-          <GridCellForField
-            key={field.field}
-            field={field}
-            columns={section.columns}
-            issues={snapshot.errors[field.field]}
-            onChange={(v) => controller.setField(field.field, v)}
-            GridCell={GridCell}
-            featureName={featureName}
-            allIssues={snapshot.errors}
-            valueDisplay="form"
-            row={snapshot.values}
-          />
-        ))}
-      </Grid>
-      {error !== null && (
-        <Banner variant="error" testId="write-form-section-error">
-          {error}
-        </Banner>
-      )}
-    </>
-  );
-
-  // type="button" (not "submit") is load-bearing: this section is deliberately
-  // NOT a nested <form> (see the component doc above), so a "submit" type
-  // would instead trigger the host RenderEdit's own form submit.
-  const submitButton = (
-    <Button
-      type="button"
-      variant="primary"
-      icon="check"
-      disabled={isSubmitting}
-      loading={isSubmitting}
-      onClick={() => void handleSubmit()}
-      testId="write-form-section-submit"
-    >
-      {section.submitLabel ?? effectiveTranslate("kumiko.actions.save")}
-    </Button>
-  );
-
-  const titleRowActions =
-    actions !== undefined ? (
-      <>
-        {actions}
-        {submitButton}
-      </>
-    ) : (
-      submitButton
-    );
-
-  // Section always flattens to a borderless divider when rendered inside
-  // RenderEdit's own <Form> in tabs mode (hideTitle) — Card frames it there
-  // instead, same reason render-edit.tsx's tabs-mode fields/extension
-  // branches stay on Card.
-  if (hideTitle) {
-    return (
-      <Card
-        slots={{
-          ...(section.description !== undefined && { subtitle: section.description }),
-          headerActions: titleRowActions,
-        }}
-        testId={`write-form-${section.title ?? "section"}`}
-      >
-        {content}
-      </Card>
-    );
-  }
-
-  // Routed through Section's `actions` slot (same mechanism render-edit.tsx
-  // uses via Form's `actions`) so the button gets the established right-
-  // aligned footer treatment instead of stretching full-width inline.
-  return (
-    <Section
-      {...(section.title !== undefined && { title: section.title })}
-      {...(section.description !== undefined && { subtitle: section.description })}
-      {...(section.icon !== undefined && { icon: section.icon })}
-      actions={titleRowActions}
-      testId={`write-form-${section.title ?? "section"}`}
-    >
-      {content}
-    </Section>
-  );
-}

package/src/context/draft-storage-context.tsx

@@ -1,39 +0,0 @@
-import { createContext, type ReactNode, useContext } from "react";
-
-// Client-side draftId storage for RenderEdit's create-mode draftKey (issue
-// #1913) — `${screen.id}:new:${draftId}` needs the same `draftId` across a
-// same-tab reload so the wizard resumes the right row instead of the leader
-// on the last-write-wins upsert. Contract only, platform-neutral — the
-// concrete impl (window.sessionStorage on web) is injected by the platform
-// package, same pattern as NavApi/window.history in app/nav.tsx. This
-// package touches no browser storage itself.
-export type DraftStorage = {
-  readonly getDraftId: (screenId: string) => string | null;
-  readonly setDraftId: (screenId: string, draftId: string) => void;
-  readonly clearDraftId: (screenId: string) => void;
-};
-
-// No-op default: without a mounted provider (unwired platform, or a test
-// that doesn't care about drafts) same-tab reload just loses draftId
-// persistence — RenderEdit falls back to its `form-draft:query:list`
-// resume path, the same one a cleared sessionStorage takes on the web.
-const noopDraftStorage: DraftStorage = {
-  getDraftId: () => null,
-  setDraftId: () => {},
-  clearDraftId: () => {},
-};
-
-const DraftStorageContext = createContext<DraftStorage>(noopDraftStorage);
-
-export type DraftStorageProviderProps = {
-  readonly value: DraftStorage;
-  readonly children: ReactNode;
-};
-
-export function DraftStorageProvider({ value, children }: DraftStorageProviderProps): ReactNode {
-  return <DraftStorageContext value={value}>{children}</DraftStorageContext>;
-}
-
-export function useDraftStorage(): DraftStorage {
-  return useContext(DraftStorageContext);
-}

package/src/hooks/__tests__/use-ai-text.test.tsx

@@ -1,177 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
-import { act, renderHook, waitFor } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { DispatcherProvider } from "../../context/dispatcher-context";
-import { useAiTextAction, useCompletion } from "../use-ai-text";
-
-function makeDispatcher(query: Dispatcher["query"]): Dispatcher {
-  return {
-    query,
-    write: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["write"],
-    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
-    statusStore: {
-      getState: () => "online",
-      subscribe: () => () => {},
-    } as unknown as Dispatcher["statusStore"],
-    async *stream() {},
-    pendingWrites: () => [],
-    pendingFiles: () => [],
-  };
-}
-
-function wrapperFor(dispatcher: Dispatcher) {
-  return ({ children }: { readonly children: ReactNode }) => (
-    <DispatcherProvider dispatcher={dispatcher}>{children}</DispatcherProvider>
-  );
-}
-
-describe("useAiTextAction", () => {
-  test("success → state='success', result carries the text", async () => {
-    const dispatcher = makeDispatcher((async (_type: string, payload: unknown) => ({
-      isSuccess: true,
-      data: {
-        type: "text",
-        text: `echo:${(payload as { text: string }).text}`,
-        usage: { inputTokens: 1, outputTokens: 1 },
-      },
-    })) as unknown as Dispatcher["query"]);
-
-    const { result } = renderHook(() => useAiTextAction(), { wrapper: wrapperFor(dispatcher) });
-
-    expect(result.current.state).toBe("idle");
-    await act(async () => {
-      await result.current.run({ mode: "correct", text: "hi" });
-    });
-
-    expect(result.current.state).toBe("success");
-    expect(result.current.result).toEqual({
-      type: "text",
-      text: "echo:hi",
-      usage: { inputTokens: 1, outputTokens: 1 },
-    });
-    expect(result.current.error).toBeNull();
-  });
-
-  test("cap_exceeded error → state='cap-exceeded'", async () => {
-    const dispatcher = makeDispatcher((async () => ({
-      isSuccess: false,
-      error: { code: "cap_exceeded", message: "capped", i18nKey: "errors.cap" },
-    })) as unknown as Dispatcher["query"]);
-
-    const { result } = renderHook(() => useAiTextAction(), { wrapper: wrapperFor(dispatcher) });
-
-    await act(async () => {
-      await result.current.run({ mode: "correct", text: "hi" });
-    });
-
-    expect(result.current.state).toBe("cap-exceeded");
-    expect(result.current.error?.code).toBe("cap_exceeded");
-  });
-
-  test("feature_disabled error → state='unavailable' (graceful degradation)", async () => {
-    const dispatcher = makeDispatcher((async () => ({
-      isSuccess: false,
-      error: { code: "feature_disabled", message: "off", i18nKey: "errors.disabled" },
-    })) as unknown as Dispatcher["query"]);
-
-    const { result } = renderHook(() => useAiTextAction(), { wrapper: wrapperFor(dispatcher) });
-
-    await act(async () => {
-      await result.current.run({ mode: "complete", text: "hi" });
-    });
-
-    expect(result.current.state).toBe("unavailable");
-  });
-
-  test("reset clears state/result/error back to idle", async () => {
-    const dispatcher = makeDispatcher((async () => ({
-      isSuccess: false,
-      error: { code: "conflict", message: "boom", i18nKey: "errors.conflict" },
-    })) as unknown as Dispatcher["query"]);
-
-    const { result } = renderHook(() => useAiTextAction(), { wrapper: wrapperFor(dispatcher) });
-    await act(async () => {
-      await result.current.run({ mode: "correct", text: "hi" });
-    });
-    expect(result.current.state).toBe("error");
-
-    act(() => result.current.reset());
-    expect(result.current.state).toBe("idle");
-    expect(result.current.error).toBeNull();
-    expect(result.current.result).toBeNull();
-  });
-});
-
-describe("useCompletion", () => {
-  test("debounces requestCompletion — only the last call within the window fires", async () => {
-    let calls = 0;
-    const dispatcher = makeDispatcher((async (_type: string, payload: unknown) => {
-      calls++;
-      return {
-        isSuccess: true,
-        data: {
-          type: "text",
-          text: `suggestion for "${(payload as { text: string }).text}"`,
-          usage: { inputTokens: 1, outputTokens: 1 },
-        },
-      };
-    }) as unknown as Dispatcher["query"]);
-
-    const { result } = renderHook(() => useCompletion(20), { wrapper: wrapperFor(dispatcher) });
-
-    act(() => {
-      result.current.requestCompletion("a");
-      result.current.requestCompletion("ab");
-      result.current.requestCompletion("abc");
-    });
-
-    await waitFor(() => expect(result.current.suggestion).not.toBeNull(), { timeout: 1000 });
-
-    expect(calls).toBe(1);
-    expect(result.current.suggestion).toBe('suggestion for "abc"');
-  });
-
-  test("empty text resets immediately without a request", async () => {
-    let calls = 0;
-    const dispatcher = makeDispatcher((async () => {
-      calls++;
-      return {
-        isSuccess: true,
-        data: { type: "text", text: "x", usage: { inputTokens: 1, outputTokens: 1 } },
-      };
-    }) as unknown as Dispatcher["query"]);
-
-    const { result } = renderHook(() => useCompletion(10), { wrapper: wrapperFor(dispatcher) });
-
-    act(() => {
-      result.current.requestCompletion("");
-    });
-    await new Promise((r) => setTimeout(r, 30));
-
-    expect(calls).toBe(0);
-    expect(result.current.suggestion).toBeNull();
-  });
-
-  test("clear cancels a pending debounce and resets the suggestion", async () => {
-    let calls = 0;
-    const dispatcher = makeDispatcher((async () => {
-      calls++;
-      return {
-        isSuccess: true,
-        data: { type: "text", text: "x", usage: { inputTokens: 1, outputTokens: 1 } },
-      };
-    }) as unknown as Dispatcher["query"]);
-
-    const { result } = renderHook(() => useCompletion(30), { wrapper: wrapperFor(dispatcher) });
-
-    act(() => {
-      result.current.requestCompletion("hello");
-    });
-    act(() => result.current.clear());
-    await new Promise((r) => setTimeout(r, 60));
-
-    expect(calls).toBe(0);
-    expect(result.current.suggestion).toBeNull();
-  });
-});

package/src/hooks/__tests__/use-disclosure.test.tsx

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { act, renderHook } from "@testing-library/react";
-import { useDisclosure } from "../use-disclosure";
-
-describe("useDisclosure", () => {
-  test("open/close/toggle steuern den Zustand", () => {
-    const { result } = renderHook(() => useDisclosure());
-    expect(result.current.open).toBe(false);
-    act(() => result.current.onOpen());
-    expect(result.current.open).toBe(true);
-    act(() => result.current.onClose());
-    expect(result.current.open).toBe(false);
-    act(() => result.current.onToggle());
-    expect(result.current.open).toBe(true);
-  });
-
-  test("Callbacks sind referenz-stabil über Re-Renders", () => {
-    const { result, rerender } = renderHook(() => useDisclosure(true));
-    const first = result.current;
-    rerender();
-    expect(result.current.onOpen).toBe(first.onOpen);
-    expect(result.current.onClose).toBe(first.onClose);
-    expect(result.current.onToggle).toBe(first.onToggle);
-  });
-});

package/src/hooks/__tests__/use-form.test.tsx

@@ -1,65 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-import type { Dispatcher, WriteResult } from "@cosmicdrift/kumiko-headless";
-import { act, renderHook } from "@testing-library/react";
-import { useForm } from "../use-form";
-
-function makeDispatcher(response?: WriteResult): Dispatcher & {
-  readonly writeSpy: ReturnType<typeof mock>;
-} {
-  const writeSpy = mock(
-    async () => response ?? ({ isSuccess: true, data: { id: "srv-1" } } as WriteResult),
-  );
-  return {
-    writeSpy,
-    write: writeSpy as unknown as Dispatcher["write"],
-    query: (async () => ({ isSuccess: true, data: null })) as unknown as Dispatcher["query"],
-    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
-    async *stream() {},
-    statusStore: {
-      getState: () => "online",
-      subscribe: () => () => {},
-    } as unknown as Dispatcher["statusStore"],
-    pendingWrites: () => [],
-    pendingFiles: () => [],
-  };
-}
-
-describe("useForm — mounted without a DispatcherProvider", () => {
-  test("does not throw on mount — fw#1999 regression", () => {
-    const { result } = renderHook(() =>
-      useForm({ initial: { title: "" }, submit: { type: "app:write:task:create" } }),
-    );
-
-    expect(result.current.snapshot.values.title).toBe("");
-  });
-
-  test("submit() without an explicit dispatcher returns isSuccess:false instead of crashing the hook", async () => {
-    const { result } = renderHook(() =>
-      useForm({ initial: { title: "hello" }, submit: { type: "app:write:task:create" } }),
-    );
-
-    const submitResult = await result.current.controller.submit();
-    expect(submitResult.validationBlocked).toBe(false);
-    expect(submitResult.isSuccess).toBe(false);
-    if (submitResult.isSuccess || submitResult.validationBlocked) {
-      throw new Error("expected write failure");
-    }
-    expect(submitResult.error.message).toMatch(/submit\(\) called without a dispatcher/);
-  });
-
-  test("submit() with an explicit dispatcher still works without a provider", async () => {
-    const dispatcher = makeDispatcher();
-    const { result } = renderHook(() =>
-      useForm({
-        initial: { title: "hello" },
-        submit: { type: "app:write:task:create", dispatcher },
-      }),
-    );
-
-    await act(async () => {
-      await result.current.controller.submit();
-    });
-
-    expect(dispatcher.writeSpy).toHaveBeenCalledWith("app:write:task:create", { title: "hello" });
-  });
-});

package/src/hooks/__tests__/use-mutation.test.tsx

@@ -1,77 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
-import { act, renderHook, waitFor } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { DispatcherProvider } from "../../context/dispatcher-context";
-import { useMutation } from "../use-mutation";
-
-function makeDispatcher(write: Dispatcher["write"]): Dispatcher {
-  return {
-    write,
-    query: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["query"],
-    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
-    statusStore: {
-      getState: () => "online",
-      subscribe: () => () => {},
-    } as unknown as Dispatcher["statusStore"],
-    async *stream() {},
-    pendingWrites: () => [],
-    pendingFiles: () => [],
-  };
-}
-
-function wrapperFor(dispatcher: Dispatcher) {
-  return ({ children }: { readonly children: ReactNode }) => (
-    <DispatcherProvider dispatcher={dispatcher}>{children}</DispatcherProvider>
-  );
-}
-
-describe("useMutation", () => {
-  test("Success setzt data, pending toggelt, Result wird durchgereicht", async () => {
-    let resolve: (() => void) | undefined;
-    const gate = new Promise<void>((r) => {
-      resolve = r;
-    });
-    const dispatcher = makeDispatcher((async (_type: string, payload: unknown) => {
-      await gate;
-      return { isSuccess: true, data: { echoed: payload } };
-    }) as unknown as Dispatcher["write"]);
-
-    const { result } = renderHook(() => useMutation<{ echoed: unknown }>("f:write:x:create"), {
-      wrapper: wrapperFor(dispatcher),
-    });
-
-    expect(result.current.pending).toBe(false);
-    let outcome: Awaited<ReturnType<typeof result.current.mutate>> | undefined;
-    act(() => {
-      void result.current.mutate({ name: "a" }).then((r) => {
-        outcome = r;
-      });
-    });
-    await waitFor(() => expect(result.current.pending).toBe(true));
-    act(() => resolve?.());
-    await waitFor(() => expect(result.current.pending).toBe(false));
-    expect(result.current.data).toEqual({ echoed: { name: "a" } });
-    expect(result.current.error).toBeNull();
-    expect(outcome?.isSuccess).toBe(true);
-  });
-
-  test("Failure setzt error, reset räumt auf", async () => {
-    const dispatcher = makeDispatcher((async () => ({
-      isSuccess: false,
-      error: { code: "conflict", message: "boom", i18nKey: "errors.conflict" },
-    })) as unknown as Dispatcher["write"]);
-
-    const { result } = renderHook(() => useMutation("f:write:x:create"), {
-      wrapper: wrapperFor(dispatcher),
-    });
-
-    await act(async () => {
-      await result.current.mutate({});
-    });
-    expect(result.current.error?.code).toBe("conflict");
-    act(() => result.current.reset());
-    expect(result.current.error).toBeNull();
-    expect(result.current.data).toBeNull();
-  });
-});

package/src/hooks/__tests__/use-stream-handler.test.tsx

@@ -1,107 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Dispatcher, DispatcherError } from "@cosmicdrift/kumiko-headless";
-import { act, renderHook, waitFor } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { DispatcherProvider } from "../../context/dispatcher-context";
-import { useStreamHandler } from "../use-stream-handler";
-
-function makeDispatcher(streamImpl: unknown): Dispatcher {
-  return {
-    write: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["write"],
-    query: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["query"],
-    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
-    stream: streamImpl as Dispatcher["stream"],
-    statusStore: {
-      getState: () => "online",
-      subscribe: () => () => {},
-    } as unknown as Dispatcher["statusStore"],
-    pendingWrites: () => [],
-    pendingFiles: () => [],
-  };
-}
-
-function wrapperFor(dispatcher: Dispatcher) {
-  return ({ children }: { readonly children: ReactNode }) => (
-    <DispatcherProvider dispatcher={dispatcher}>{children}</DispatcherProvider>
-  );
-}
-
-describe("useStreamHandler", () => {
-  test("start accumulates chunks then status=done", async () => {
-    const dispatcher = makeDispatcher(async function* () {
-      yield { i: 0 };
-      yield { i: 1 };
-    });
-
-    const { result } = renderHook(() => useStreamHandler<{ i: number }>("f:stream:x:tail"), {
-      wrapper: wrapperFor(dispatcher),
-    });
-
-    await act(async () => {
-      await result.current.start({ count: 2 });
-    });
-
-    await waitFor(() => expect(result.current.status).toBe("done"));
-    expect(result.current.chunks).toEqual([{ i: 0 }, { i: 1 }]);
-    expect(result.current.error).toBeNull();
-  });
-
-  test("stream error sets status=error and error envelope", async () => {
-    const err: DispatcherError = {
-      code: "access_denied",
-      httpStatus: 403,
-      i18nKey: "errors.access",
-      message: "denied",
-    };
-    const dispatcher = makeDispatcher(async function* () {
-      yield* []; // satisfy generator shape; error is the only outcome
-      throw err;
-    });
-
-    const { result } = renderHook(() => useStreamHandler("f:stream:x:tail"), {
-      wrapper: wrapperFor(dispatcher),
-    });
-
-    await act(async () => {
-      await result.current.start();
-    });
-
-    await waitFor(() => expect(result.current.status).toBe("error"));
-    expect(result.current.error?.code).toBe("access_denied");
-  });
-
-  test("abort during stream resets status to idle (no late done)", async () => {
-    let release!: () => void;
-    const gate = new Promise<void>((r) => {
-      release = r;
-    });
-    const dispatcher = makeDispatcher(async function* (
-      _t: string,
-      _p: unknown,
-      opts?: { signal?: AbortSignal },
-    ) {
-      yield { i: 0 };
-      await gate;
-      if (opts?.signal?.aborted) {
-        const e = { code: "aborted", httpStatus: 0, i18nKey: "x", message: "aborted" };
-        throw e;
-      }
-      yield { i: 1 };
-    });
-
-    const { result } = renderHook(() => useStreamHandler<{ i: number }>("f:stream:x:tail"), {
-      wrapper: wrapperFor(dispatcher),
-    });
-
-    let started!: Promise<void>;
-    act(() => {
-      started = result.current.start();
-    });
-    await waitFor(() => expect(result.current.chunks).toEqual([{ i: 0 }]));
-    act(() => result.current.abort());
-    release();
-    await started;
-    expect(result.current.chunks).toEqual([{ i: 0 }]);
-    expect(result.current.status).toBe("idle");
-  });
-});