@cosmicdrift/kumiko-renderer 0.307.0 → 0.309.0

package/src/app/row-actions.ts

@@ -1,6 +1,5 @@
 import type {
   EntityEditScreenDefinition,
-  IconKey,
   RelatedListToolbarAction,
   RowAction,
   RowActionDrawer,
@@ -11,6 +10,9 @@ import type {
 } from "@cosmicdrift/kumiko-framework/ui-types";
 import { evalFieldCondition } from "@cosmicdrift/kumiko-framework/ui-types";
 import type { Dispatcher, ListRowViewModel, Translate } from "@cosmicdrift/kumiko-headless";
+import { resolveActionIcon } from "@cosmicdrift/kumiko-types/action-icon";
+import type { IconKey } from "@cosmicdrift/kumiko-types/nav-icon";
+import type { RenderEditAction } from "../components/render-edit-types";
 import type { ToolbarActionButton } from "../components/render-list";
 import type { DataTableRowAction } from "../primitives";
 import type { NavApi, ScreenTarget } from "./nav";
@@ -48,61 +50,6 @@ export function isWriteHandlerRowAction(action: RowAction): action is RowActionW
   return action.kind === "writeHandler" || action.kind === undefined;
 }
 
-// Part B (fw-ui-defaults): id-derived default icon for actions that never
-// declared one — a screen author still gets a recognizable glyph instead of
-// a bare label. Checked against the actually registered IconKey vocabulary
-// (nav-icon.ts) — no entry for verbs without a matching icon (e.g. "start",
-// "pause").
-const ACTION_ICON_BY_ID: Readonly<Partial<Record<string, IconKey>>> = {
-  delete: "trash",
-  edit: "pencil",
-  create: "plus",
-  new: "plus",
-  add: "plus",
-  view: "eye",
-  open: "eye",
-  cancel: "x",
-  reject: "x",
-  complete: "check",
-  resolve: "check",
-  approve: "check",
-  archive: "archive",
-  publish: "upload",
-  duplicate: "copy",
-  copy: "copy",
-  download: "download",
-  refresh: "refresh",
-  retry: "refresh",
-  settings: "settings",
-  share: "share",
-  send: "send",
-};
-
-// Ids are kebab-case (RowAction.id doc): aggregate-object-verb
-// ("order-ship") or verb-prefix ("add-item").
-function kebabLastSegment(id: string): string {
-  const idx = id.lastIndexOf("-");
-  return idx === -1 ? id : id.slice(idx + 1);
-}
-
-function kebabFirstSegment(id: string): string {
-  const idx = id.indexOf("-");
-  return idx === -1 ? id : id.slice(0, idx);
-}
-
-// Resolution order: author-declared `icon` wins, then the id-derived
-// default (full id, then its last kebab segment, then its first kebab
-// segment). `declared` is `undefined` for ToolbarAction, which has no
-// author-facing icon field.
-export function resolveActionIcon(id: string, declared?: IconKey): IconKey | undefined {
-  if (declared !== undefined) return declared;
-  return (
-    ACTION_ICON_BY_ID[id] ??
-    ACTION_ICON_BY_ID[kebabLastSegment(id)] ??
-    ACTION_ICON_BY_ID[kebabFirstSegment(id)]
-  );
-}
-
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   if (typeof value !== "object" || value === null) return false;
   const proto: object | null = Object.getPrototypeOf(value);
@@ -473,3 +420,215 @@ export function buildProjectionToolbarActions(options: {
   }
   return out.length > 0 ? out : undefined;
 }
+
+function buildNavigateRecordAction(
+  action: RowActionNavigate,
+  options: {
+    readonly record: Readonly<Record<string, unknown>>;
+    readonly translate: Translate;
+    readonly nav: NavApi;
+    readonly host: ReturnHost | undefined;
+    readonly actionIcon: IconKey | undefined;
+    readonly defaultScreenTargetEntityId: string | undefined;
+    readonly sameEntityScreenId: ((targetScreen: string) => string | undefined) | undefined;
+  },
+): RenderEditAction | undefined {
+  const {
+    record,
+    translate,
+    nav,
+    host,
+    actionIcon,
+    defaultScreenTargetEntityId,
+    sameEntityScreenId,
+  } = options;
+  const runParams = (): void => {
+    const params =
+      action.params !== undefined ? evalRowExtractor(action.params, record) : undefined;
+    if (params !== undefined) nav.setSearchParams(stringifyNavParams(params));
+  };
+  if (action.entity !== undefined) {
+    const targetEntity = action.entity;
+    const id = action.entityId !== undefined ? String(record[action.entityId] ?? "") : "";
+    return {
+      id: action.id,
+      label: translate(action.label),
+      ...(action.style !== undefined && { style: action.style }),
+      confirmRequired: false,
+      ...(actionIcon !== undefined && { icon: actionIcon }),
+      onPress: () => {
+        // No entityId on record (id === "") → nothing to navigate to.
+        if (id !== "") {
+          nav.navigate({ entity: targetEntity, id });
+          runParams();
+        }
+      },
+    };
+  }
+  if (action.screen !== undefined) {
+    const explicit =
+      action.entityId !== undefined ? String(record[action.entityId] ?? "") : undefined;
+    const fallback = sameEntityScreenId?.(action.screen) ?? defaultScreenTargetEntityId;
+    const navEntityId = explicit ?? fallback;
+    const targetScreen = action.screen;
+    return {
+      id: action.id,
+      label: translate(action.label),
+      ...(action.style !== undefined && { style: action.style }),
+      confirmRequired: false,
+      ...(actionIcon !== undefined && { icon: actionIcon }),
+      onPress: () => {
+        const target: ScreenTarget = {
+          screenId: targetScreen,
+          ...(navEntityId !== undefined && navEntityId !== "" && { entityId: navEntityId }),
+        };
+        const params =
+          action.params !== undefined
+            ? stringifyNavParams(evalRowExtractor(action.params, record))
+            : undefined;
+        navigateWithReturnTo(nav, target, host, params);
+      },
+    };
+  }
+  return undefined;
+}
+
+function buildDrawerRecordAction(
+  action: RowActionDrawer,
+  options: {
+    readonly record: Readonly<Record<string, unknown>>;
+    readonly translate: Translate;
+    readonly actionIcon: IconKey | undefined;
+    readonly openDrawer: (
+      action: RowActionDrawer,
+      initialValues: Readonly<Record<string, unknown>> | undefined,
+    ) => void;
+  },
+): RenderEditAction {
+  const { record, translate, actionIcon, openDrawer } = options;
+  return {
+    id: action.id,
+    label: translate(action.label),
+    ...(action.style !== undefined && { style: action.style }),
+    confirmRequired: false,
+    ...(actionIcon !== undefined && { icon: actionIcon }),
+    onPress: () => {
+      const initialValues =
+        action.params !== undefined ? evalRowExtractor(action.params, record) : undefined;
+      openDrawer(action, initialValues);
+    },
+  };
+}
+
+function buildWriteHandlerRecordAction(
+  action: RowActionWriteHandler,
+  options: {
+    readonly record: Readonly<Record<string, unknown>>;
+    readonly translate: Translate;
+    readonly actionIcon: IconKey | undefined;
+    readonly dispatcher: Dispatcher;
+    readonly onWriteSuccess: () => void | Promise<void>;
+  },
+): RenderEditAction {
+  const { record, translate, actionIcon, dispatcher, onWriteSuccess } = options;
+  return {
+    id: action.id,
+    label: translate(action.label),
+    ...(action.style !== undefined && { style: action.style }),
+    ...(actionIcon !== undefined && { icon: actionIcon }),
+    ...(action.confirm !== undefined && { confirm: translate(action.confirm) }),
+    ...(action.confirmLabel !== undefined && {
+      confirmLabel: translate(action.confirmLabel),
+    }),
+    onPress: async () => {
+      const payload =
+        action.payload !== undefined
+          ? evalRowExtractor(action.payload, record)
+          : { id: record["id"] };
+      const result = await dispatcher.write(action.handler, payload);
+      if (!result.isSuccess) {
+        throw new WriteFailedError(result.error, dispatcherErrorText(result.error, translate));
+      }
+      await onWriteSuccess();
+    },
+  };
+}
+
+// Shared builder for a RowAction[] evaluated against one "record"
+// context (not a specific list row) — a head card's `screen.actions`, an
+// entityEdit's own `screen.actions`, and any section-level
+// `actions`/`emptyState.action` are all this same shape: a RowAction
+// resolved against the record currently being viewed/edited, independent of
+// any table row.
+export function buildRecordActions(options: {
+  readonly actions: readonly RowAction[];
+  readonly record: Readonly<Record<string, unknown>>;
+  readonly translate: Translate;
+  readonly nav: NavApi;
+  readonly host: ReturnHost | undefined;
+  readonly dispatcher: Dispatcher | undefined;
+  readonly openDrawer: (
+    action: RowActionDrawer,
+    initialValues: Readonly<Record<string, unknown>> | undefined,
+  ) => void;
+  /** Called after a writeHandler action succeeds (refetch/reload). */
+  readonly onWriteSuccess: () => void | Promise<void>;
+  /** Screen-target navigate default entityId when the action declares no
+   *  explicit `entityId` field-source. A caller editing a fixed entity can
+   *  pass its own `entityId` here directly (the record it already is). A
+   *  caller whose shown record may differ from the navigate target's entity
+   *  resolves this per-target via `sameEntityScreenId` instead. */
+  readonly defaultScreenTargetEntityId?: string;
+  /** Given a navigate action's target screen id, returns the record id to
+   *  default to IF that screen edits the same entity the current record
+   *  belongs to (cross-feature lookup) — undefined otherwise. Omitted by
+   *  callers with no such cross-screen lookup. */
+  readonly sameEntityScreenId?: (targetScreen: string) => string | undefined;
+}): readonly RenderEditAction[] | undefined {
+  const {
+    actions,
+    record,
+    translate,
+    nav,
+    host,
+    dispatcher,
+    openDrawer,
+    onWriteSuccess,
+    defaultScreenTargetEntityId,
+    sameEntityScreenId,
+  } = options;
+  const out: RenderEditAction[] = [];
+  for (const action of actions) {
+    if (action.visible !== undefined && !evalFieldCondition(action.visible, record)) continue;
+    const actionIcon = resolveActionIcon(action.id, action.icon);
+    if (action.kind === "navigate") {
+      const built = buildNavigateRecordAction(action, {
+        record,
+        translate,
+        nav,
+        host,
+        actionIcon,
+        defaultScreenTargetEntityId,
+        sameEntityScreenId,
+      });
+      if (built !== undefined) out.push(built);
+      continue;
+    }
+    if (action.kind === "drawer") {
+      out.push(buildDrawerRecordAction(action, { record, translate, actionIcon, openDrawer }));
+      continue;
+    }
+    // writeHandler — skip without a dispatcher instead of crashing.
+    if (dispatcher === undefined) continue;
+    out.push(
+      buildWriteHandlerRecordAction(action, {
+        record,
+        translate,
+        actionIcon,
+        dispatcher,
+        onWriteSuccess,
+      }),
+    );
+  }
+  return out.length > 0 ? out : undefined;
+}

package/src/changes.json

@@ -1,4 +1,11 @@
 [
+  {
+    "version": "0.308.0",
+    "type": "improvement",
+    "title": "projectionDetail/entityEdit-tabs sections render through one Card frame, get section-level actions and a relatedList emptyState (fw#3234)",
+    "detail": "Every section kind in a tabs-mode layout (fields, extension, relatedList, writeForm) now renders inside exactly one card — extension and writeForm sections previously fell back to a borderless divider there because Section always flattens when rendered inside RenderEdit's own <Form>, so their content (and, for writeForm, its submit button) had no card chrome. EditFieldsSection, EditExtensionSection, EditRelatedListSection and EditWriteFormSection all gain an optional `actions?: readonly RowAction[]`, rendered as buttons in that section's own title row (never a footer). EditRelatedListSection also gains an optional `emptyState?: { title, description?, action? }`, forwarded to the related list's DataTable when it has zero rows. RenderEdit gains a `buildSectionActions` prop the caller uses to resolve a section's RowAction[] against the record being viewed/edited — kumiko-screen.tsx wires this via a new shared `buildRecordActions` helper (row-actions.ts), replacing what used to be two separately maintained header-actions builders.",
+    "migration": "Additive: existing screens are unaffected. A projectionDetail/entityEdit-tabs screen with an extension or writeForm section previously relying on the flattened (no card) look in tabs mode now sees that section framed like every other section kind."
+  },
   {
     "version": "0.306.0",
     "type": "fix",

package/src/components/__tests__/related-list-section-empty-state.test.tsx

@@ -0,0 +1,143 @@
+// EditRelatedListSection.emptyState (fw#3234) — forwarded to the DataTable's
+// own `emptyState` prop, rendered as title/description plus an optional
+// record-bound action dispatched the same way a toolbarAction is.
+
+import { describe, expect, test } from "bun:test";
+import type { EditRelatedListSectionViewModel } from "@cosmicdrift/kumiko-headless";
+import { fireEvent, render, screen as rtlScreen, waitFor } from "@testing-library/react";
+import type { ComponentType, ReactNode } from "react";
+import { NavProvider } from "../../app/nav";
+import { DispatcherProvider } from "../../context/dispatcher-context";
+import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
+import { kumikoDefaultTranslations } from "../../i18n-defaults";
+import {
+  type ButtonProps,
+  type CorePrimitives,
+  type DataTableProps,
+  PrimitivesProvider,
+  type TextProps,
+} from "../../primitives";
+import { RelatedListSection } from "../related-list-section";
+
+const noop = () => {};
+const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
+
+const testDataTable: ComponentType<DataTableProps> = ({ rows, emptyState }) =>
+  rows.length === 0 && emptyState !== undefined ? <div>{emptyState}</div> : <table />;
+
+function testPrimitives(): CorePrimitives {
+  return {
+    Button: (props: ButtonProps) => (
+      <button type="button" data-testid={props.testId} onClick={() => void props.onClick?.()}>
+        {props.children}
+      </button>
+    ),
+    Banner: passChildren,
+    Field: passChildren,
+    Input: noop,
+    DataTable: testDataTable,
+    Form: noop,
+    Section: passChildren,
+    Card: passChildren,
+    Grid: passChildren,
+    GridCell: passChildren,
+    Text: ({ children }: TextProps) => <span>{children}</span>,
+    Heading: noop,
+    Dialog: noop,
+    Modal: noop,
+    Lightbox: noop,
+    ConfigSourceBadge: noop,
+    ConfigCascadeView: noop,
+    Link: noop,
+  } as unknown as CorePrimitives;
+}
+
+const baseSection: EditRelatedListSectionViewModel = {
+  kind: "relatedList",
+  title: "Notifications",
+  query: "orders:query:notifications:list",
+  columns: [{ field: "name" }],
+};
+
+function renderEmpty(
+  section: EditRelatedListSectionViewModel,
+  onWrite?: (type: string, payload: unknown) => void,
+) {
+  const dispatcher = {
+    write: (async (type: string, payload: unknown) => {
+      onWrite?.(type, payload);
+      return { isSuccess: true, data: null };
+    }) as never,
+    query: (async () => ({ isSuccess: true, data: { rows: [], nextCursor: null } })) as never,
+    batch: (async () => ({ isSuccess: true, results: [] })) as never,
+    statusStore: { getState: () => "online", subscribe: () => () => {} } as never,
+    async *stream() {},
+    pendingWrites: () => [],
+    pendingFiles: () => [],
+  };
+  return render(
+    <LocaleProvider
+      resolver={createStaticLocaleResolver({ locale: "en-US" })}
+      fallbackBundles={[kumikoDefaultTranslations]}
+    >
+      <DispatcherProvider dispatcher={dispatcher}>
+        <PrimitivesProvider value={testPrimitives()}>
+          <NavProvider
+            value={{
+              route: undefined,
+              navigate: noop,
+              replace: noop,
+              hrefFor: () => "#",
+              searchParams: {},
+              setSearchParams: noop,
+            }}
+          >
+            <RelatedListSection
+              section={section}
+              parentId="order-1"
+              record={{ id: "order-1" }}
+              featureName="orders"
+            />
+          </NavProvider>
+        </PrimitivesProvider>
+      </DispatcherProvider>
+    </LocaleProvider>,
+  );
+}
+
+describe("RelatedListSection — emptyState (fw#3234)", () => {
+  test("no emptyState declared: DataTable renders its own fallback, not a custom one", async () => {
+    renderEmpty(baseSection);
+    await waitFor(() => rtlScreen.getByRole("table"));
+    expect(rtlScreen.queryByText("No notifications yet")).toBeNull();
+  });
+
+  test("custom emptyState renders title, description, and dispatches its action's payload evaluated against the parent record", async () => {
+    const writes: Array<{ type: string; payload: unknown }> = [];
+    const section: EditRelatedListSectionViewModel = {
+      ...baseSection,
+      emptyState: {
+        title: "No notifications yet",
+        description: "New ones show up here.",
+        action: {
+          kind: "writeHandler",
+          id: "seed",
+          label: "actions.seed",
+          handler: "orders:write:seed-notifications",
+          payload: { pick: ["id"] },
+        },
+      },
+    };
+    renderEmpty(section, (type, payload) => writes.push({ type, payload }));
+
+    await waitFor(() => rtlScreen.getByText("No notifications yet"));
+    expect(rtlScreen.getByText("New ones show up here.")).toBeTruthy();
+
+    fireEvent.click(rtlScreen.getByTestId("render-edit-action-seed"));
+    await waitFor(() => expect(writes.length).toBe(1));
+    expect(writes[0]).toEqual({
+      type: "orders:write:seed-notifications",
+      payload: { id: "order-1" },
+    });
+  });
+});

package/src/components/__tests__/related-list-section.test.tsx

@@ -189,7 +189,7 @@ function renderRelatedList(
 }
 
 describe("RelatedListSection — tabs-mode card chrome (fw#2722)", () => {
-  test("hideTitle (tabs mode) renders the list without a Section wrapper, keeps the table frame, and marks scrollBody", async () => {
+  test("hideTitle (tabs mode) renders the list without a Section wrapper, drops the table frame (the tab card frames it), and marks scrollBody", async () => {
     const { dispatcher } = stubDispatcher();
     let capturedChromeless: boolean | undefined;
     let capturedScrollBody: boolean | undefined;
@@ -221,7 +221,7 @@ describe("RelatedListSection — tabs-mode card chrome (fw#2722)", () => {
 
     await waitFor(() => expect(rtlScreen.getByTestId("row-r1")).toBeTruthy());
     expect(rtlScreen.queryByTestId(`related-list-${historySection.title}`)).toBeNull();
-    expect(capturedChromeless).toBeUndefined();
+    expect(capturedChromeless).toBe(true);
     expect(capturedScrollBody).toBe(true);
   });
 

package/src/components/__tests__/render-field-number-grouping.test.tsx

@@ -0,0 +1,76 @@
+// Read-only number display (`field.readOnly: true`, no own `renderer`) goes
+// through readOnlyDisplayText's own Intl.NumberFormat call, independent of
+// the headless `applyFormatSpec` path already covered by
+// format.test.tsx — `field.grouping` gates it the same way (fw#3234).
+
+import { describe, expect, test } from "bun:test";
+import type { EditFieldViewModel } from "@cosmicdrift/kumiko-headless";
+import { cleanup, render, screen } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
+import { type CorePrimitives, PrimitivesProvider, type TextProps } from "../../primitives";
+import { RenderField } from "../render-field";
+
+const noop = (): ReactNode => null;
+const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
+const DefaultText = ({ testId, children }: TextProps): ReactNode => (
+  <span data-testid={testId}>{children}</span>
+);
+
+const testPrimitives: CorePrimitives = {
+  Button: noop,
+  Banner: noop,
+  Field: passChildren,
+  Input: noop,
+  DataTable: noop,
+  Form: noop,
+  Section: noop,
+  Card: noop,
+  Grid: noop,
+  GridCell: noop,
+  Text: DefaultText,
+  Heading: noop,
+  Dialog: noop,
+  Modal: noop,
+  Lightbox: noop,
+  ConfigSourceBadge: noop,
+  ConfigCascadeView: noop,
+  Link: noop,
+};
+
+function numberField(grouping: boolean | undefined): EditFieldViewModel {
+  return {
+    field: "population",
+    label: "Population",
+    type: "number",
+    value: 2021,
+    visible: true,
+    readOnly: true,
+    required: false,
+    ...(grouping !== undefined && { grouping }),
+  };
+}
+
+function renderReadOnly(locale: string, grouping: boolean | undefined): string {
+  cleanup();
+  render(
+    <LocaleProvider resolver={createStaticLocaleResolver({ locale })}>
+      <PrimitivesProvider value={testPrimitives}>
+        <RenderField field={numberField(grouping)} onChange={() => {}} valueDisplay="text" />
+      </PrimitivesProvider>
+    </LocaleProvider>,
+  );
+  return screen.getByTestId("field-value-population").textContent ?? "";
+}
+
+describe("RenderField — read-only number grouping (fw#3234)", () => {
+  test("groups thousands by default, locale-aware", () => {
+    expect(renderReadOnly("en-US", undefined)).toBe("2,021");
+    expect(renderReadOnly("de-DE", undefined)).toBe("2.021");
+  });
+
+  test("grouping: false renders the digits without a thousands separator", () => {
+    expect(renderReadOnly("en-US", false)).toBe("2021");
+    expect(renderReadOnly("de-DE", false)).toBe("2021");
+  });
+});

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

@@ -17,6 +17,7 @@ import { kumikoDefaultTranslations } from "../../i18n-defaults";
 import {
   type BannerProps,
   type ButtonProps,
+  type CardProps,
   type CorePrimitives,
   PrimitivesProvider,
   type SectionProps,
@@ -66,6 +67,27 @@ const testSection: ComponentType<SectionProps> = ({ testId, subtitle, children,
   </div>
 );
 
+// Mirrors DefaultCard's slots (title/subtitle/headerActions) closely enough
+// to distinguish "framed via Card" from "framed via Section" in tests —
+// tabs mode (hideTitle) uses Card because Section flattens inside this
+// component's host Form.
+const testCard: ComponentType<CardProps> = ({ testId, slots, children }) => (
+  <div data-testid={testId}>
+    {slots?.title !== undefined && (
+      <h3 data-testid={testId !== undefined ? `${testId}-title` : undefined}>{slots.title}</h3>
+    )}
+    {slots?.subtitle !== undefined && (
+      <p data-testid={testId !== undefined ? `${testId}-subtitle` : undefined}>{slots.subtitle}</p>
+    )}
+    <div data-testid={testId !== undefined ? `${testId}-body` : undefined}>{children}</div>
+    {slots?.headerActions !== undefined && (
+      <div data-testid={testId !== undefined ? `${testId}-actions` : undefined}>
+        {slots.headerActions}
+      </div>
+    )}
+  </div>
+);
+
 function testPrimitives(): CorePrimitives {
   return {
     Button: testButton,
@@ -75,7 +97,7 @@ function testPrimitives(): CorePrimitives {
     DataTable: noop,
     Form: noop,
     Section: testSection,
-    Card: passChildren,
+    Card: testCard,
     Grid: passChildren,
     GridCell: passChildren,
     Text: noop,
@@ -244,6 +266,37 @@ describe("WriteFormSection", () => {
   });
 });
 
+// Tabs mode (hideTitle) frames through Card instead of Section — Section
+// flattens to a borderless divider inside the host RenderEdit's own Form,
+// which would otherwise leave the submit button with no card chrome.
+describe("WriteFormSection — tabs mode (hideTitle)", () => {
+  test("renders via Card, no title text, submit button lands in headerActions", () => {
+    const { dispatcher } = stubDispatcher();
+    render(
+      <LocaleProvider
+        resolver={createStaticLocaleResolver({ locale: "en-US" })}
+        fallbackBundles={[kumikoDefaultTranslations]}
+      >
+        <DispatcherProvider dispatcher={dispatcher}>
+          <PrimitivesProvider value={testPrimitives()}>
+            <WriteFormSection
+              section={noteSection}
+              featureName="orders"
+              onSubmitted={noop}
+              hideTitle
+            />
+          </PrimitivesProvider>
+        </DispatcherProvider>
+      </LocaleProvider>,
+    );
+
+    expect(rtlScreen.queryByTestId("write-form-Add note-title")).toBeNull();
+    const actions = rtlScreen.getByTestId("write-form-Add note-actions");
+    const button = rtlScreen.getByTestId("write-form-section-submit");
+    expect(actions.contains(button)).toBe(true);
+  });
+});
+
 // section.description exists on EditWriteFormSection to make a self-service
 // write form usable without training (same doc-promise as EditFieldsSection),
 // but WriteFormSection never read it — the ViewModel translated it correctly,