@tristan2828/ui-foundation 3.9.0 → 3.11.0

package/README.md

@@ -4,8 +4,8 @@
 [![release](https://github.com/Tristan2828/ui-foundation/actions/workflows/release.yml/badge.svg)](https://github.com/Tristan2828/ui-foundation/actions/workflows/release.yml)
 
 The shared layer of a family of small, contract-first, database-backed React
-apps: shadcn primitives, the `DataTable`/`EntityForm` composites, an app
-shell with session-cookie auth, the gateway's error seam, design tokens,
+apps: shadcn primitives, the `DataTable`/`EntityView`/`EntityForm`
+composites, an app shell with session-cookie auth, the gateway's error seam, design tokens,
 lint rules, Playwright suites, and the conventions an AI agent follows to
 build on it. Apps upgrade by bumping the version.
 
@@ -18,7 +18,7 @@ than installing this by hand:
 
 | Import | What |
 |---|---|
-| `@tristan2828/ui-foundation` | `AppShell`, `DataTable`, `EntityForm`, `ErrorState`, `MultiChoice`, `MultiReference`, `ListEditor`, `PasswordInput`, `RouteErrorBoundary`, `FoundationProviders`, `LoginRoute`, `RegisterRoute`, `useAuth`, `useTableUrlState`, `useDebouncedValue`, `createQueryClient`, `cn`; types `Page`, `AppError`, `QuerySpec` |
+| `@tristan2828/ui-foundation` | `AppShell`, `DataTable`, `EntityView`, `EntityForm`, `Markdown`, `ErrorState`, `MultiChoice`, `MultiReference`, `ListEditor`, `PasswordInput`, `RouteErrorBoundary`, `FoundationProviders`, `LoginRoute`, `RegisterRoute`, `useAuth`, `useTableUrlState`, `useDebouncedValue`, `createQueryClient`, `cn`; types `Page`, `AppError`, `QuerySpec` |
 | `@tristan2828/ui-foundation/ui/<name>` | shadcn primitives: badge, button, calendar, card, checkbox, combobox, dialog, empty, field, input, input-group, label, popover, select, separator, sheet, sidebar, skeleton, sonner, spinner, switch, table, textarea, tooltip |
 | `@tristan2828/ui-foundation/gateway` | `safeFetch`, `toAppError`, `networkError` — for an app's `src/api/gateway/` only |
 | `@tristan2828/ui-foundation/mocks` | MSW: `authHandlers`, `resetMockAuth`, `getMockCurrentUser`, `MOCK_USER`, `exposeMswForE2E` |

package/conventions/AGENTS.md

@@ -3,8 +3,8 @@
 ## Stack
 Vite + React 19 + TypeScript, Tailwind v4, shadcn/ui (Base UI primitives),
 React Router v7, TanStack Query. The shared layer — primitives, the
-`DataTable`/`EntityForm` composites, the app shell, auth, the gateway error
-seam, design tokens, lint rules — is the npm package
+`DataTable`/`EntityView`/`EntityForm` composites, the app shell, auth,
+the gateway error seam, design tokens, lint rules — is the npm package
 `@tristan2828/ui-foundation`, updated by bumping its version. Everything in
 `src/` is this app's own.
 
@@ -75,7 +75,8 @@ is right. Do not disable, skip, or work around it.
 
 ## Required States
 Every data view handles: loading, empty, error, and success. Use
-`<Skeleton>`, `<Empty>`, and the error boundary — `DataTable` already does.
+`<Skeleton>`, `<Empty>`, and the error boundary — `DataTable` already does,
+and `EntityView` (one record) adds not found: a plain 404, never a retry.
 Every screen has one Playwright test per state, forced via MSW overrides
 (`@tristan2828/ui-foundation/testing`).
 

package/conventions/agents/skills/new-entity/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: new-entity
-description: This skill should be used when the user asks to "add an entity", "add a new entity", "scaffold a CRUD screen", "add a resource screen", or names a new domain object (e.g. "add Invoice") that needs a spec, gateway, mocks, table, and form built following this repo's widgets reference pattern.
+description: This skill should be used when the user asks to "add an entity", "add a new entity", "scaffold a CRUD screen", "add a resource screen", or names a new domain object (e.g. "add Invoice") that needs a spec, gateway, mocks, table, view and form built following this repo's widgets reference pattern.
 allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Agent
 ---
 

package/conventions/docs/add-an-entity.md

@@ -1,7 +1,7 @@
 # Add an Entity
 
 The most-repeated task in this system: add a full CRUD entity — spec, mocks,
-gateway, tests, table, form, routes — following the patterns in
+gateway, tests, table, view, form, routes — following the patterns in
 `src/routes/widgets/`. This file is the only copy of the steps, written for
 **any AI coding tool or a person**: follow it directly ("add a Game entity
 following docs/foundation/add-an-entity.md"). In Claude Code,
@@ -56,6 +56,11 @@ is a filled-in example while the Widgets demo is still here).
   unresolved item under "Open questions", or needs a field type or screen
   shape the foundation doesn't support yet (the supported list is in the
   template). Write the case in `docs/BLOCKERS.md`.
+- **The plan's "Screens" line names a view** (`list, view, create, edit,
+  delete`), and its "View screen" section says what the view shows. A plan
+  written before the view existed has neither: ask the developer whether
+  to add them before step 1. The reference files build the table *with* a
+  view, where Edit and Delete live, so the table has no row actions.
 
 1. **Add `<Entity>` to `openapi.yaml`** — schema, list, get, create, update,
    delete — exactly as the plan specifies: its fields, types, required
@@ -162,18 +167,85 @@ is a filled-in example while the Widgets demo is still here).
      `<Entity>Create`/`<Entity>Update`, plus the form ↔ wire conversion
      functions — see `widgetToFormValues`/`formValuesToWidgetCreate` for
      the shape)
+   - `src/routes/widgets/widget-format.ts` →
+     `src/routes/<entity>/<entity>-format.ts` (the lookups and formatters
+     both the columns and the view render values with: badge variant maps,
+     date and number formatters, the done-count)
    - `src/routes/widgets/widgets-columns.tsx` →
-     `src/routes/<entity>/<entity>-columns.tsx` (column defs; split any
-     row-action dialogs into their own file, as
-     `delete-widget-action.tsx` does — a fast-refresh hazard otherwise)
+     `src/routes/<entity>/<entity>-columns.tsx` (column defs: the plan's
+     title field is a link to the record's view, cell pattern 16, and
+     there is no row-actions column)
    - `src/routes/widgets/widgets-table.tsx` →
      `src/routes/<entity>/<entity>-table.tsx` — thin consumer of the
      foundation's `<DataTable>`. Swap the type, columns, and toolbar
      filters.
+   - `src/routes/widgets/widget-view.tsx` →
+     `src/routes/<entity>/<entity>-view.tsx` — thin consumer of the
+     foundation's `<EntityView>`. Swap the title, badges and sections for
+     the plan's "View screen" (below).
+   - `src/routes/widgets/delete-widget-action.tsx` →
+     `src/routes/<entity>/delete-<entity>-action.tsx` (Delete in the
+     view's header: the confirm dialog, then `onDeleted` leaves for the
+     list; its own file, a fast-refresh hazard otherwise)
    - `src/routes/widgets/widget-form.tsx` →
      `src/routes/<entity>/<entity>-form.tsx` — thin consumer of the
      foundation's `<EntityForm>` (its `danger` slot takes an edit-only
-     delete). Swap the zod schema and fields.
+     delete). Swap the zod schema and fields. Every way out lands on a
+     view (below).
+
+   **The view** is the read-only page for one record, at `/<entity>/:id`.
+   `<EntityView>` owns its loading skeleton, its not-found state (another
+   user's record is the same plain 404, with a way back to the list and
+   no retry) and its error state with retry. The screen supplies what the
+   plan's "View screen" section lists:
+
+   - **Title and badges.** The plan's title field is the page's `<h1>`.
+     Its badge fields sit beside it, each the same `Badge` and variant map
+     as its table cell. Edit (a `Button` rendering a `Link` to
+     `/<entity>/:id/edit`) and the delete action go in `actions`.
+   - **Sections**, one per row of the plan's section table, in order.
+     Fields are label/value rows (`fields`), labelled as on the form. A
+     section that holds one long text or one sub-record list is a block
+     (`content`) with no label of its own, since a label would only repeat
+     the heading.
+   - **Every value renders the way its table cell does**: badges, names
+     of linked records, a done-count, from the shared lookups in
+     `<entity>-format.ts`. Never re-derive one for the view.
+   - **An empty value is passed through as it is** (`null`, `''`, or
+     `list.length > 0 && …`), and `EntityView` shows the field's
+     `emptyLabel`, the plan's "not set" label, never a blank. A yes/no is
+     never empty: it reads Yes or No (cell pattern 12).
+   - **A reference links to the referenced record's view** when that
+     entity has one: the name, from the same lookup by id the table uses,
+     inside `<Link to={`/<other>/${id}`}>`. Without a view, the plain name
+     (Widget's categories have none).
+   - **Sub-records are read-only**: the done-count, then each item in
+     order with its state as a glyph and words, never a checkbox
+     (`ChecklistItems` in `widget-view.tsx`). A list of links: each an
+     `<a target="_blank" rel="noreferrer">` with an `ExternalLinkIcon`
+     and a visually hidden "(opens in a new tab)".
+   - **Long text the plan marks Markdown** renders through the
+     foundation's `<Markdown>`: headings, lists, tables and links, links
+     opening in a new tab; raw HTML shows as the characters typed, never
+     as markup. The app needs no Markdown dependency of its own. Plain
+     long text renders as text (`whitespace-pre-line` keeps its line
+     breaks).
+   - **Quick actions and editing in place aren't in the playbook yet**
+     (flipping a yes/no, changing a status or ticking an item from the
+     view). Don't build them on your own: a row's value can hold a control
+     and `actions` takes any buttons, so they'll slot in once a release
+     adds them.
+
+   **The table opens the view, and the form returns to it.** The title
+   column's link is the way in (a `yes/no` marked `toggle` stays in its
+   row). Saving an edit, or cancelling one, goes back to the record's view;
+   creating opens the new record's view (the id the create returns);
+   cancelling a create goes back to the list. Each navigates with
+   `{ replace: true }`, so Back from the view doesn't reopen the form. The
+   create and update mutations put the saved record into its detail cache
+   (`setQueryData`), so the view shows the save at once, and the delete
+   mutation drops it (`removeQueries`), so the view it leaves never
+   refetches a record that's gone (`use-widgets.ts`).
 
    **`<SelectValue>` shows the value, not the label.** Base UI renders the
    raw *value*, and `placeholder` only applies when the value is `null`.
@@ -239,14 +311,26 @@ is a filled-in example while the Widgets demo is still here).
      them choose. That is how every pattern in the catalogue was picked.
    - Any colour involved: [`design-language.md`](design-language.md). Most
      values should stay grey, and colour is never the only signal.
-7. **Register routes** for `/<entity>`, `/<entity>/new`,
-   `/<entity>/:id/edit` in `src/App.tsx`, and add a nav entry to
-   `src/nav.ts`.
-8. **Add Playwright specs for both screens**, one test per state
+7. **Register routes** for `/<entity>`, `/<entity>/new`, `/<entity>/:id`
+   (the view) and `/<entity>/:id/edit` in `src/App.tsx`, and add a nav
+   entry to `src/nav.ts`.
+8. **Add Playwright specs for all three screens**, one test per state
    (`loading`, `empty`, `error`, `validation`, `success`), forced through
    MSW overrides — `forceMswOverride`, `waitForMswReady` and the
    `window.__msw` handle from `@tristan2828/ui-foundation/testing`, and
-   `e2e/widgets-table.spec.ts`/`e2e/widget-form.spec.ts` for the pattern.
+   `e2e/widgets-table.spec.ts`/`e2e/widget-form.spec.ts`/
+   `e2e/widget-view.spec.ts` for the pattern. The view's states are
+   loading, not found (a 404: "Not found", the way back, no retry), error
+   (a failed load, then Try again recovering) and success (every section,
+   each value as its cell shows it), plus the sparse record showing its
+   "not set" labels and no blank value. Its flows: the table's title link
+   opens it, saving and cancelling the form return to it, creating opens
+   the new record's view, and Delete confirms then lands on the list. If
+   the plan has Markdown long text, a test forces a record whose text has
+   a heading, a list, a table, a link and raw HTML, and asserts the HTML
+   shows as text. Add the view's spec to `playwright.config.ts`'s
+   `mobile-chrome` `testMatch`, with a test that at phone width each
+   label sits above its value and nothing scrolls sideways.
    States forced via a first-load init script (loading, load-time error)
    need `page.addInitScript` before navigation; states forced after the
    page is already up (a mutation's error response) can use a
@@ -258,20 +342,28 @@ is a filled-in example while the Widgets demo is still here).
    which cannot see requests the MSW service worker makes
    (`e2e/msw-contract.spec.ts` has an example).
 9. **Register the nav entry and route names** in `e2e/shell.spec.ts`'s
-   `NAV_ENTRIES` so the shell smoke test covers the new screen, and add
-   `/<entity>/new` to `e2e/a11y.spec.ts`'s `formRoutes` (the table page is
-   picked up from the sidebar automatically; the form isn't in it).
+   `NAV_ENTRIES` so the shell smoke test covers the new screen, add
+   `/<entity>/new` to `e2e/a11y.spec.ts`'s `formRoutes`, and add the view
+   of a full record and of the sparse one to its `viewRoutes` (the table
+   page is picked up from the sidebar automatically; the form and the view
+   aren't in it).
 10. **`npm run verify`.** Fix until it passes. Then stop — do not add
     anything beyond what this list covers; note ideas in the app's
     backlog instead.
 
 ## What not to copy
 
+- The saved-views row in `widgets-table.tsx` (`VIEWS`, the "Saved views"
+  button group and `visibleColumns`) unless the plan's List screen lists
+  saved views. When it does, copy it: `useTableUrlState`'s third argument
+  takes the views, `activeView` says which one the filters are, and that
+  view's `columns` go to `DataTable`'s `visibleColumns` (the table's own
+  default list when no view is active, or `undefined` for every column).
 - `src/api/gateway/widgets.ts`, `src/mocks/data.ts`, `src/mocks/handlers.ts`
   are demo-domain content — write the entity's own versions rather than
   adapting these by find-and-replace.
-- The composites (`DataTable`, `EntityForm`, `ErrorState`, `AppShell`)
-  are the foundation's and shared by every app. If a new entity needs a
+- The composites (`DataTable`, `EntityForm`, `EntityView`, `Markdown`,
+  `ErrorState`, `AppShell`) are the foundation's and shared by every app. If a new entity needs a
   capability they don't have (a new field-type widget, say), don't copy
   one into `src/` to change it: raise it for the foundation (AGENTS.md
   "Changing the Foundation") and build the screen once the release ships.

package/conventions/docs/cell-patterns.md

@@ -7,8 +7,9 @@ per-entity, and only the shape is reusable. Copy the markup into your
 
 Patterns 1–10 were each chosen for a real column, from a page of
 alternatives ([`column-options.md`](column-options.md)), not designed in the abstract.
-Pattern 12 (boolean) is the template's own reference: Widget's In Stock
-column renders it and its specs pin it. The other patterns from 11 on are
+Patterns 12 (boolean) and 16 (title linking to its view) are the
+template's own references: Widget's In Stock and Name columns render them
+and their specs pin them. The other patterns from 11 on are
 marked **Unproven**: written ahead of a real
 column, so no app has tested them on real data yet. Prefer a proven
 pattern when one fits. When you use an unproven one, say so in the
@@ -350,3 +351,40 @@ now", "happened"). Widget's In Stock column is the reference
   stable").
 - **Cost:** one click changes data, with no confirmation. Only for values
   that are cheap to flip back; never for anything destructive.
+
+## 16. Title linking to the record's view
+
+The column that names a record (its name or title), when the entity has a
+view (`/<entity>/:id`). Widget's Name column is the reference
+(`src/routes/widgets/widgets-columns.tsx`).
+
+```tsx
+const TITLE_LINK_CLASS =
+  'rounded-sm font-medium text-foreground underline-offset-4 outline-none hover:underline ' +
+  'focus-visible:underline focus-visible:ring-3 focus-visible:ring-ring/50'
+
+cell: ({ row }) => (
+  <Link to={`/widgets/${row.original.id}`} className={TITLE_LINK_CLASS}>
+    {row.original.name}
+  </Link>
+)
+```
+
+- **A plain `Link`, not a `Button`.** It goes somewhere and does nothing
+  else; a button-styled title down every row is a wall of buttons
+  (pattern 7's cost).
+- **The record's own name is the link text**, so each row's link is
+  already distinct for a screen reader, with no `aria-label`.
+- `font-medium` marks it as the row's name; the underline appears on hover
+  and keyboard focus. Foreground, not `text-primary`: it's the row's
+  heading, and a column of coloured text pulls the eye from every other
+  column.
+- **The view replaces the row actions.** Edit and Delete live in the
+  view's header, so a table whose title links to a view has no actions
+  column. A `yes/no` marked `toggle` (pattern 15) stays in its row.
+- **A reference to another record** (a cell showing a linked record's
+  name) uses the same link when *that* entity has a view, pointing at
+  `/<other>/${id}`, on the table and on the view alike.
+- **Cost:** none to speak of. Specs that match the title as a cell still
+  work (`getByRole('cell', { name })` reads the link's text); ones that
+  opened the form from a row button go through the view's Edit instead.

package/conventions/docs/entity-plan-template.md

@@ -23,7 +23,9 @@ One or two sentences: what one record is, and who uses the screens.
 - **Field**: camelCase, as it appears in the API (`releaseDate`).
 - **Type** — what the foundation supports today:
   - *Demonstrated by the Widget reference* (copied directly): `text` (one
-    line), `long text`, `decimal` (fixed places — say how many),
+    line), `long text` (say `Markdown` when it's written in Markdown, like
+    notes or a write-up: the view renders its headings, lists, tables and
+    links, and it's never a table column), `decimal` (fixed places — say how many),
     `date-time`, `email`, `yes/no` (a boolean that is always yes or no:
     say its default and the filter's three labels, e.g. Any stock /
     In stock / Out of stock), `single choice` (list the options, in display
@@ -56,7 +58,8 @@ One or two sentences: what one record is, and who uses the screens.
   a screen — a Base UI `Select` can't take `""` as an item value, so the
   pattern needs a sentinel and gets the display wrong without one.
 - **List**: `column` if it shows in the table, and `sortable` if you can
-  sort by it; blank if it's form-only. A `yes/no` can also say `toggle`:
+  sort by it; blank if it's only on the form and the view. The title
+  field's column links to the record's view. A `yes/no` can also say `toggle`:
   flipped straight from its row, saved on its own (cell pattern 15).
 - **Filter**: `search` (the text search box), `yes` (a filter control), or
   blank.
@@ -72,6 +75,8 @@ per list; delete the section if there are none.
 - Most items: 50.
 - In the table: a done-count (`2/6 done`), or blank if the list isn't
   shown.
+- On the view: always shown, read-only: the done-count, then each item in
+  order (a `url` item field opens in a new tab).
 
 | Field | Label | Type | Required | Options / rules |
 |---|---|---|---|---|
@@ -87,12 +92,49 @@ per list; delete the section if there are none.
 
 - Default sort:
 - Page size: 10 unless there's a reason.
+- Saved views (optional; delete if none): one row per view, a button
+  above the filters that sets every filter and the sort in one press.
+  Columns: blank for the table's usual columns, or the exact columns the
+  view shows, for a view of one kind of record that shows a field only
+  that kind uses. The columns last while the view's filters do; any other
+  filter puts the usual columns back. If the usual columns should leave
+  out a field only a view shows, say so here.
+
+| View | Filters | Sort | Columns |
+|---|---|---|---|
+| All tasks | none | dueDate asc | |
+| Bugs | kind = bug | dueDate asc | title, severity, assignee, dueDate |
+
 - Anything else the table must show or do:
 
+## View screen
+
+The read-only page for one record (`/<entity>/:id`), opened by clicking
+its title in the table. Edit and Delete live in its header, so the table
+has no row actions. Every field it shows renders as its table cell does.
+
+- Title: the field that names a record, shown as the page heading and
+  linked from the table: `title`.
+- Badges beside the title: a few status-like fields, as badges: `status`,
+  `priority`.
+- Sections, in order. Each lists its fields in the order they show. A
+  section holding a single long text or a single sub-records list shows
+  it under the section's heading, with no label of its own.
+
+| Section | Fields |
+|---|---|
+| Details | dueDate, project, tags |
+| Checklist | checklist |
+| Notes | notes |
+
+- "Not set" labels: what an empty optional field reads as on the view
+  (`dueDate`: No due date; `checklist`: No items). A field not listed here
+  reads "Not set". A `yes/no` is never empty: it reads Yes or No.
+
 ## Screens and access
 
-- Screens: list, create, edit, delete (the only shape the playbook builds
-  today).
+- Screens: list, view, create, edit, delete (the shape the playbook
+  builds).
 - Ownership: **shared** (every signed-in user sees every record) or
   **per-user** (each user sees only their own).
 

package/dist/components/app/data-table.d.ts

@@ -52,5 +52,13 @@ export type DataTableProps<TData extends Record<string, unknown>> = {
      * unaffected. See conventions/docs/entity-plan-template.md "Default sort".
      */
     enableSortingRemoval?: boolean;
+    /**
+     * The ids of the columns to show; the rest are hidden. They keep their
+     * order in `columns`. Leave undefined to show every column. A table
+     * with saved views passes the active view's `columns`
+     * (useTableUrlState's `activeView`), or its own default list when no
+     * view is active, which can leave out a column only one view shows.
+     */
+    visibleColumns?: readonly string[];
 };
-export declare function DataTable<TData extends Record<string, unknown>>({ columns, data, total, page, pageSize, onPageChange, sorting, onSortingChange, isLoading, error, onRetry, emptyTitle, emptyDescription, emptyAction, toolbar, getRowId, pinFirstColumn, pinLastColumn, enableSortingRemoval, }: DataTableProps<TData>): import("react").JSX.Element;
+export declare function DataTable<TData extends Record<string, unknown>>({ columns, data, total, page, pageSize, onPageChange, sorting, onSortingChange, isLoading, error, onRetry, emptyTitle, emptyDescription, emptyAction, toolbar, getRowId, pinFirstColumn, pinLastColumn, enableSortingRemoval, visibleColumns, }: DataTableProps<TData>): import("react").JSX.Element;

package/dist/components/app/data-table.js

@@ -20,6 +20,20 @@ import { Button } from '../ui/button.js';
 import { Empty, EmptyDescription, EmptyHeader, EmptyTitle } from '../ui/empty.js';
 import { Skeleton } from '../ui/skeleton.js';
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow, } from '../ui/table.js';
+// A column def's id as TanStack resolves it (constructColumn): `id`, then
+// `accessorKey` with dots as underscores, then a string header. Group
+// columns are looked through to their leaves, which visibility is keyed by.
+function leafColumnIds(columns) {
+    return columns.flatMap((column) => {
+        if ('columns' in column && column.columns)
+            return leafColumnIds(column.columns);
+        const accessorKey = 'accessorKey' in column ? column.accessorKey : undefined;
+        const id = column.id ??
+            (accessorKey === undefined ? undefined : String(accessorKey).replaceAll('.', '_')) ??
+            (typeof column.header === 'string' ? column.header : undefined);
+        return id === undefined ? [] : [id];
+    });
+}
 function TableSkeleton({ columnCount }) {
     return (_jsx("div", { className: "flex flex-col gap-2 p-2", "data-state": "loading", children: Array.from({ length: 5 }, (_, row) => (_jsx("div", { className: "flex gap-4", children: Array.from({ length: columnCount }, (_, col) => (_jsx(Skeleton, { className: "h-8 flex-1" }, col))) }, row))) }));
 }
@@ -109,8 +123,13 @@ function useBottomScrollbar(containerRef, isSuccessView) {
     }, [containerRef, isSuccessView, isOverflowing]);
     return { barRef, isOverflowing, scrollWidth };
 }
-export function DataTable({ columns, data, total, page, pageSize, onPageChange, sorting, onSortingChange, isLoading, error, onRetry, emptyTitle, emptyDescription, emptyAction, toolbar, getRowId, pinFirstColumn, pinLastColumn, enableSortingRemoval, }) {
+export function DataTable({ columns, data, total, page, pageSize, onPageChange, sorting, onSortingChange, isLoading, error, onRetry, emptyTitle, emptyDescription, emptyAction, toolbar, getRowId, pinFirstColumn, pinLastColumn, enableSortingRemoval, visibleColumns, }) {
     const pageCount = Math.max(1, Math.ceil(total / pageSize));
+    // TanStack treats a column missing from this map as visible, so every
+    // column gets an entry once a list is given.
+    const columnVisibility = visibleColumns
+        ? Object.fromEntries(leafColumnIds(columns).map((id) => [id, visibleColumns.includes(id)]))
+        : {};
     const table = useLegacyTable({
         data,
         columns,
@@ -118,6 +137,7 @@ export function DataTable({ columns, data, total, page, pageSize, onPageChange,
         state: {
             sorting,
             pagination: { pageIndex: page - 1, pageSize },
+            columnVisibility,
         },
         manualSorting: true,
         ...(enableSortingRemoval === undefined ? {} : { enableSortingRemoval }),
@@ -143,7 +163,7 @@ export function DataTable({ columns, data, total, page, pageSize, onPageChange,
     const isSuccessView = !error && !isLoading && !isPastLastPage && !isEmpty;
     const containerRef = useRef(null);
     const { barRef, isOverflowing, scrollWidth } = useBottomScrollbar(containerRef, Boolean(pinFirstColumn) && isSuccessView);
-    return (_jsxs("div", { className: "flex flex-col gap-4", children: [toolbar, error ? (_jsx(ErrorState, { error: error, onRetry: onRetry })) : isLoading || isPastLastPage ? (_jsx(TableSkeleton, { columnCount: columns.length })) : isEmpty ? (_jsxs(Empty, { "data-state": "empty", children: [_jsxs(EmptyHeader, { children: [_jsx(EmptyTitle, { children: emptyTitle }), emptyDescription && _jsx(EmptyDescription, { children: emptyDescription })] }), emptyAction] })) : (_jsxs(_Fragment, { children: [_jsxs(Table, { "data-state": "success", containerRef: containerRef, 
+    return (_jsxs("div", { className: "flex flex-col gap-4", children: [toolbar, error ? (_jsx(ErrorState, { error: error, onRetry: onRetry })) : isLoading || isPastLastPage ? (_jsx(TableSkeleton, { columnCount: table.getVisibleLeafColumns().length })) : isEmpty ? (_jsxs(Empty, { "data-state": "empty", children: [_jsxs(EmptyHeader, { children: [_jsx(EmptyTitle, { children: emptyTitle }), emptyDescription && _jsx(EmptyDescription, { children: emptyDescription })] }), emptyAction] })) : (_jsxs(_Fragment, { children: [_jsxs(Table, { "data-state": "success", containerRef: containerRef, 
                         // With the sticky bar below as the visible scrollbar, hide the
                         // container's own. It stays overflow-x-auto and fully
                         // scrollable (wheel, trackpad, drag, and the sync effect); it

package/dist/components/app/entity-view.d.ts

@@ -0,0 +1,48 @@
+import { type ReactNode } from 'react';
+import type { AppError } from '../../api/contracts.js';
+export type EntityViewField = {
+    label: string;
+    /**
+     * The value as the screen renders it. `null`, `undefined`, `false`, `''`
+     * and an empty array all count as empty and show `emptyLabel` instead,
+     * so `{tags.map(...)}` or `{email}` can be passed as they are.
+     */
+    value: ReactNode;
+    /** What an empty value reads as: the plan's "not set" label. Defaults to "Not set". */
+    emptyLabel?: string;
+};
+/**
+ * A titled card on the view: either label/value rows (`fields`), or one
+ * block of content under the heading with no label of its own (`content`),
+ * for long text (`<Markdown>`) or a sub-record list, where a label would
+ * only repeat the heading. A block that's empty shows `emptyLabel`, the
+ * same rule as a field.
+ */
+export type EntityViewSection = {
+    /** The section's heading (an <h2>). Unique on the page. */
+    title: string;
+    fields: EntityViewField[];
+} | {
+    title: string;
+    content: ReactNode;
+    emptyLabel?: string;
+};
+export type EntityViewProps = {
+    /** The record's name or title, the page's <h1>. */
+    title?: string;
+    /** A few status-like values beside the title, as `<Badge>`s. */
+    badges?: ReactNode;
+    /** The header's actions: an Edit button, a Delete with its confirm dialog. */
+    actions?: ReactNode;
+    sections: EntityViewSection[];
+    isLoading: boolean;
+    /** A `notfound` error (including another user's record) shows "Not found" and a way back, never a retry. */
+    error?: AppError | null;
+    onRetry?: () => void;
+    /** The entity's list: a link above the title, and the not-found state's way out. */
+    back: {
+        to: string;
+        label: string;
+    };
+};
+export declare function EntityView({ title, badges, actions, sections, isLoading, error, onRetry, back, }: EntityViewProps): import("react").JSX.Element;

package/dist/components/app/entity-view.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Generic read-only view of one record, the read-side partner of
+// EntityForm: the record's title with a few status badges beside it, an
+// actions area (Edit, Delete), and sections of label/value rows laid out to
+// read rather than as a form. It owns the loading, not-found and error
+// states, the way DataTable does for a list.
+//
+// Deliberately thin, like EntityForm: each value is the screen's own
+// markup, built with the same cell patterns as the table's columns
+// (badges, names of linked records, a done-count), and <Markdown> for
+// long text. This component never formats a field. What it does guarantee
+// is that an empty value reads as the plan's "not set" label, never a
+// blank.
+//
+// A value can be any markup, a control included, and `actions` takes any
+// buttons: that's the room left for quick actions on this page (a toggle,
+// a status change, ticking a checklist item) without the form.
+import { useId } from 'react';
+import { Link } from 'react-router';
+import { ArrowLeftIcon, SearchXIcon } from 'lucide-react';
+import { ErrorState } from './error-state.js';
+import { Button } from '../ui/button.js';
+import { Card, CardContent, CardHeader } from '../ui/card.js';
+import { Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle, } from '../ui/empty.js';
+import { Skeleton } from '../ui/skeleton.js';
+const DEFAULT_EMPTY_LABEL = 'Not set';
+function isEmptyValue(value) {
+    return (value === null ||
+        value === undefined ||
+        value === false ||
+        value === '' ||
+        (Array.isArray(value) && value.length === 0));
+}
+function BackLink({ back }) {
+    return (_jsxs(Link, { to: back.to, className: "inline-flex w-fit items-center gap-1 rounded-sm type-label text-muted-foreground outline-none hover:text-foreground focus-visible:ring-3 focus-visible:ring-ring/50", children: [_jsx(ArrowLeftIcon, { "aria-hidden": "true", className: "size-4" }), back.label] }));
+}
+function orEmptyLabel(value, emptyLabel) {
+    return isEmptyValue(value) ? (_jsx("span", { className: "text-muted-foreground", children: emptyLabel ?? DEFAULT_EMPTY_LABEL })) : (value);
+}
+// Label beside value from `sm` up; below it (a phone) the label sits
+// above its value, so nothing is squeezed into a narrow second column.
+function FieldRow({ field }) {
+    return (_jsxs("div", { className: "flex flex-col gap-1 py-3 first:pt-0 last:pb-0 sm:grid sm:grid-cols-[minmax(8rem,12rem)_1fr] sm:gap-6", children: [_jsx("dt", { className: "type-label text-muted-foreground", children: field.label }), _jsx("dd", { className: "min-w-0 type-body break-words text-foreground", children: orEmptyLabel(field.value, field.emptyLabel) })] }));
+}
+function ViewSection({ section }) {
+    const headingId = useId();
+    return (_jsx("section", { "aria-labelledby": headingId, children: _jsxs(Card, { children: [_jsx(CardHeader, { children: _jsx("h2", { id: headingId, className: "type-section-title text-foreground", children: section.title }) }), _jsx(CardContent, { children: 'fields' in section ? (_jsx("dl", { className: "flex flex-col divide-y divide-border", children: section.fields.map((field) => (_jsx(FieldRow, { field: field }, field.label))) })) : (_jsx("div", { className: "min-w-0 type-body break-words text-foreground", children: orEmptyLabel(section.content, section.emptyLabel) })) })] }) }));
+}
+function EntityViewSkeleton() {
+    return (_jsxs("div", { className: "flex max-w-4xl flex-col gap-6", "data-state": "loading", children: [_jsx(Skeleton, { className: "h-5 w-24" }), _jsxs("div", { className: "flex flex-col gap-2", children: [_jsx(Skeleton, { className: "h-7 w-64 max-w-full" }), _jsx(Skeleton, { className: "h-5 w-40" })] }), Array.from({ length: 2 }, (_, section) => (_jsxs(Card, { children: [_jsx(CardHeader, { children: _jsx(Skeleton, { className: "h-5 w-32" }) }), _jsx(CardContent, { className: "flex flex-col gap-4", children: Array.from({ length: 4 }, (_, row) => (_jsxs("div", { className: "flex flex-col gap-1 sm:flex-row sm:gap-6", children: [_jsx(Skeleton, { className: "h-5 w-32" }), _jsx(Skeleton, { className: "h-5 flex-1" })] }, row))) })] }, section)))] }));
+}
+export function EntityView({ title, badges, actions, sections, isLoading, error, onRetry, back, }) {
+    if (error?.kind === 'notfound') {
+        // A record that doesn't exist and one that belongs to another user are
+        // the same plain 404, so this never says which. Retrying can't help.
+        return (_jsxs(Empty, { "data-state": "notfound", children: [_jsxs(EmptyHeader, { children: [_jsx(EmptyMedia, { variant: "icon", children: _jsx(SearchXIcon, {}) }), _jsx(EmptyTitle, { children: "Not found" }), _jsx(EmptyDescription, { children: error.message })] }), _jsx(EmptyContent, { children: _jsxs(Button, { size: "sm", variant: "outline", nativeButton: false, render: _jsx(Link, { to: back.to }), children: ["Back to ", back.label] }) })] }));
+    }
+    if (error)
+        return _jsx(ErrorState, { error: error, onRetry: onRetry });
+    if (isLoading)
+        return _jsx(EntityViewSkeleton, {});
+    return (_jsxs("div", { className: "flex max-w-4xl flex-col gap-6", "data-state": "success", children: [_jsx(BackLink, { back: back }), _jsxs("header", { className: "flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between", children: [_jsxs("div", { className: "flex min-w-0 flex-col gap-2", children: [_jsx("h1", { className: "type-page-title break-words text-foreground", children: title }), badges && _jsx("div", { className: "flex flex-wrap items-center gap-1.5", children: badges })] }), actions && _jsx("div", { className: "flex shrink-0 flex-wrap items-center gap-2", children: actions })] }), sections.map((section) => (_jsx(ViewSection, { section: section }, section.title)))] }));
+}

package/dist/components/app/markdown.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentProps } from 'react';
+export type MarkdownProps = {
+    /** The Markdown source. Raw HTML in it is shown as text, never rendered. */
+    children: string;
+    className?: string;
+} & Omit<ComponentProps<'div'>, 'children'>;
+export declare function Markdown({ children, className, ...rest }: MarkdownProps): import("react").JSX.Element;

package/dist/components/app/markdown.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import ReactMarkdown, {} from 'react-markdown';
+import remarkGfm from 'remark-gfm';
+import { cn } from 'cn';
+import { ExternalLinkIcon, SquareCheckIcon, SquareIcon } from 'lucide-react';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '../ui/table.js';
+const REMARK_PLUGINS = [remarkGfm];
+// Every element react-markdown hands over carries `node` (the syntax tree
+// node). It isn't a DOM attribute, so it's dropped before spreading.
+function omitNode(props) {
+    const rest = { ...props };
+    delete rest.node;
+    return rest;
+}
+const COMPONENTS = {
+    h1: (props) => _jsx("h3", { ...omitNode(props), className: "type-section-title mt-2 text-foreground" }),
+    h2: (props) => _jsx("h4", { ...omitNode(props), className: "type-section-title mt-2 text-foreground" }),
+    h3: (props) => _jsx("h5", { ...omitNode(props), className: "type-label mt-1 text-foreground" }),
+    h4: (props) => _jsx("h6", { ...omitNode(props), className: "type-label mt-1 text-foreground" }),
+    h5: (props) => _jsx("h6", { ...omitNode(props), className: "type-label mt-1 text-foreground" }),
+    h6: (props) => _jsx("h6", { ...omitNode(props), className: "type-label mt-1 text-foreground" }),
+    a: (props) => {
+        const { href, children, ...rest } = omitNode(props);
+        if (!href)
+            return _jsx("span", { children: children });
+        return (_jsxs("a", { ...rest, href: href, target: "_blank", rel: "noreferrer", className: "text-primary underline underline-offset-4 hover:text-primary/80", children: [children, _jsx(ExternalLinkIcon, { "aria-hidden": "true", className: "ml-0.5 inline size-3 align-baseline" }), _jsx("span", { className: "sr-only", children: " (opens in a new tab)" })] }));
+    },
+    ul: (props) => {
+        const { className, ...rest } = omitNode(props);
+        const isTaskList = className?.includes('contains-task-list');
+        return _jsx("ul", { ...rest, className: cn('flex flex-col gap-1', isTaskList ? 'list-none' : 'list-disc pl-6') });
+    },
+    ol: (props) => _jsx("ol", { ...omitNode(props), className: "flex list-decimal flex-col gap-1 pl-6" }),
+    li: (props) => {
+        const { className, ...rest } = omitNode(props);
+        return _jsx("li", { ...rest, className: cn(className?.includes('task-list-item') && 'flex items-start gap-2') });
+    },
+    // A GitHub task-list box (`- [x] done`). Read-only, so a glyph with its
+    // state in words, never a checkbox someone will try to tick.
+    input: ({ checked }) => checked ? (_jsx(SquareCheckIcon, { role: "img", "aria-label": "Done", className: "mt-0.5 size-4 shrink-0 text-foreground" })) : (_jsx(SquareIcon, { role: "img", "aria-label": "Not done", className: "mt-0.5 size-4 shrink-0 text-muted-foreground" })),
+    blockquote: (props) => (_jsx("blockquote", { ...omitNode(props), className: "flex flex-col gap-3 border-l-2 border-border pl-4 text-muted-foreground" })),
+    hr: () => _jsx("hr", { className: "border-border" }),
+    pre: (props) => (_jsx("pre", { ...omitNode(props), className: "overflow-x-auto rounded-lg bg-muted p-3 font-mono text-foreground [&_code]:bg-transparent [&_code]:p-0" })),
+    code: (props) => _jsx("code", { ...omitNode(props), className: "rounded bg-muted px-1 py-0.5 font-mono text-foreground" }),
+    img: (props) => {
+        const { alt, ...rest } = omitNode(props);
+        return _jsx("img", { ...rest, alt: alt ?? '', loading: "lazy", className: "max-w-full rounded-md" });
+    },
+    // GFM tables use the package's own table, zebra stripes and density
+    // tokens included, so a table in the notes reads like every other table.
+    table: (props) => _jsx(Table, { ...omitNode(props) }),
+    thead: (props) => _jsx(TableHeader, { ...omitNode(props) }),
+    tbody: (props) => _jsx(TableBody, { ...omitNode(props) }),
+    tr: (props) => _jsx(TableRow, { ...omitNode(props) }),
+    th: (props) => _jsx(TableHead, { ...omitNode(props) }),
+    td: (props) => _jsx(TableCell, { ...omitNode(props) }),
+};
+export function Markdown({ children, className, ...rest }) {
+    return (_jsx("div", { "data-slot": "markdown", ...rest, className: cn('flex min-w-0 flex-col gap-3 type-body text-foreground break-words', className), children: _jsx(ReactMarkdown, { remarkPlugins: REMARK_PLUGINS, components: COMPONENTS, children: children }) }));
+}

package/dist/hooks/table-url-changes.d.ts

@@ -7,8 +7,15 @@ export type TableView<F extends string, M extends string> = {
     filters?: Partial<Record<F, string>>;
     multiFilters?: Partial<Record<M, string[]>>;
     sort?: Sort;
+    /**
+     * The ids of the columns this view shows, for DataTable's
+     * `visibleColumns`. Leave it out to show the table's default columns.
+     * Applies only while the view is active (see activeViewOf).
+     */
+    columns?: readonly string[];
 };
 export declare function serializeSort(next: Sort): string | null;
 export declare function applyUrlChanges(previous: URLSearchParams, changes: UrlChanges): URLSearchParams;
 export declare function viewToUrlChanges<F extends string, M extends string>(filterNames: readonly F[], multiFilterNames: readonly M[], view: TableView<F, M>): UrlChanges;
+export declare function activeViewOf<F extends string, M extends string, V extends string>(views: Readonly<Record<V, TableView<F, M>>>, filters: Readonly<Record<F, string>>, multiFilters: Readonly<Record<M, readonly string[]>>): V | null;
 export {};

package/dist/hooks/table-url-changes.js

@@ -30,3 +30,17 @@ export function viewToUrlChanges(filterNames, multiFilterNames, view) {
         page: null,
     };
 }
+// Which of `views` the current filters are: the first whose filters and
+// multi filters equal the URL's exactly (multi filters in any order), or
+// null. A view is active only while it is still "this combination and
+// nothing else", so adding or changing any filter returns the table to its
+// default columns: a view's columns are chosen for the records its filters
+// select, and would hide a field those other records fill. Sort and page
+// don't change which records are shown, so they don't count. Decided with
+// the developer on 2026-10-05.
+export function activeViewOf(views, filters, multiFilters) {
+    const sameItems = (a, b) => a.length === b.length && [...a].sort().every((item, index) => item === [...b].sort()[index]);
+    const matches = (view) => Object.keys(filters).every((name) => filters[name] === (view.filters?.[name] ?? '')) &&
+        Object.keys(multiFilters).every((name) => sameItems(multiFilters[name], view.multiFilters?.[name] ?? []));
+    return Object.keys(views).find((id) => matches(views[id])) ?? null;
+}

package/dist/hooks/use-table-url-state.d.ts

@@ -1,10 +1,11 @@
 import type { SortingState } from '../components/app/data-table.js';
 import { type TableView } from './table-url-changes.js';
-export declare function useTableUrlState<F extends string, M extends string = never>(filterNames: readonly F[], multiFilterNames?: readonly M[]): {
+export declare function useTableUrlState<F extends string, M extends string = never, V extends string = never>(filterNames: readonly F[], multiFilterNames?: readonly M[], views?: Readonly<Record<V, TableView<NoInfer<F>, NoInfer<M>>>>): {
     page: number;
     sorting: SortingState;
     filters: Record<F, string>;
     multiFilters: Record<M, string[]>;
+    activeView: V | null;
     setPage: (next: number) => void;
     setSorting: (next: SortingState) => void;
     setFilter: (name: F, value: string) => void;

package/dist/hooks/use-table-url-state.js

@@ -1,5 +1,5 @@
 import { useSearchParams } from 'react-router';
-import { applyUrlChanges, serializeSort, viewToUrlChanges } from './table-url-changes.js';
+import { activeViewOf, applyUrlChanges, serializeSort, viewToUrlChanges, } from './table-url-changes.js';
 // A table's page, sort and filters, kept in the URL query string
 // (`?page=2&sort=name:asc&search=mouse&tags=fragile&tags=bulky`) instead of
 // component state, so they survive going to the edit form and back, a
@@ -10,14 +10,20 @@ import { applyUrlChanges, serializeSort, viewToUrlChanges } from './table-url-ch
 // (multi-choice fields) are string arrays, repeated in the URL the same way
 // the API takes them. Changing the sort or any filter returns to page 1.
 //
+// `views` are the table's saved views, by id. `activeView` is the id of the
+// one the current filters are, or null (activeViewOf() says when a view
+// counts as active); pass that view's `columns` to DataTable. A view is
+// pressed with applyView().
+//
 // Every setter is one update(), and must stay one: see setFilters.
-export function useTableUrlState(filterNames, multiFilterNames = []) {
+export function useTableUrlState(filterNames, multiFilterNames = [], views = {}) {
     const [params, setParams] = useSearchParams();
     const page = Math.max(1, Math.floor(Number(params.get('page'))) || 1);
     const [sortField, sortDir] = (params.get('sort') ?? '').split(':');
     const sorting = sortField ? [{ id: sortField, desc: sortDir === 'desc' }] : [];
     const filters = Object.fromEntries(filterNames.map((name) => [name, params.get(name) ?? '']));
     const multiFilters = Object.fromEntries(multiFilterNames.map((name) => [name, params.getAll(name)]));
+    const activeView = activeViewOf(views, filters, multiFilters);
     function update(changes) {
         setParams((previous) => applyUrlChanges(previous, changes), { replace: true });
     }
@@ -26,6 +32,7 @@ export function useTableUrlState(filterNames, multiFilterNames = []) {
         sorting,
         filters,
         multiFilters,
+        activeView,
         setPage: (next) => update({ page: next > 1 ? String(next) : null }),
         setSorting: (next) => update({ sort: serializeSort(next), page: null }),
         setFilter: (name, value) => update({ [name]: value, page: null }),

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 export { AppShell, type AppShellProps, type NavItem } from './components/app/app-shell.js';
 export { DataTable, type DataTableProps, type SortingState } from './components/app/data-table.js';
 export { EntityForm, type EntityFormProps } from './components/app/entity-form.js';
+export { EntityView, type EntityViewField, type EntityViewProps, type EntityViewSection, } from './components/app/entity-view.js';
 export { ErrorState } from './components/app/error-state.js';
 export { FoundationProviders } from './components/app/foundation-providers.js';
+export { Markdown, type MarkdownProps } from './components/app/markdown.js';
 export { MockModeBanner } from './components/app/mock-mode-banner.js';
 export { MultiChoice } from './components/app/multi-choice.js';
 export { MultiReference } from './components/app/multi-reference.js';

package/dist/index.js

@@ -6,8 +6,10 @@
 export { AppShell } from './components/app/app-shell.js';
 export { DataTable } from './components/app/data-table.js';
 export { EntityForm } from './components/app/entity-form.js';
+export { EntityView, } from './components/app/entity-view.js';
 export { ErrorState } from './components/app/error-state.js';
 export { FoundationProviders } from './components/app/foundation-providers.js';
+export { Markdown } from './components/app/markdown.js';
 export { MockModeBanner } from './components/app/mock-mode-banner.js';
 export { MultiChoice } from './components/app/multi-choice.js';
 export { MultiReference } from './components/app/multi-reference.js';

package/dist/testing/index.d.ts

@@ -18,6 +18,12 @@ export type A11ySuiteOptions = {
      * plus an edit route when the form shows something only existing data has.
      */
     formRoutes: readonly string[];
+    /**
+     * Record views (`/<entity>/:id`, built on EntityView), which aren't in
+     * the sidebar either: each entity's view of a full record, plus its
+     * sparse one, so both filled values and "not set" labels are checked.
+     */
+    viewRoutes?: readonly string[];
     /** Screens outside the app shell, e.g. '/login' (and '/register' if the app has it). */
     loggedOutRoutes: readonly string[];
 };
@@ -29,7 +35,7 @@ export type A11ySuiteOptions = {
  * dark-mode tokens readable. The theme follows the OS setting, so
  * emulateMedia switches it.
  */
-export declare function defineA11ySuite({ formRoutes, loggedOutRoutes }: A11ySuiteOptions): void;
+export declare function defineA11ySuite({ formRoutes, viewRoutes, loggedOutRoutes }: A11ySuiteOptions): void;
 export type MockModeBannerSuiteOptions = {
     /** Screens to check, logged-out ones included (e.g. '/login'). */
     routes: readonly string[];

package/dist/testing/index.js

@@ -68,7 +68,7 @@ async function navRoutes(page, isMobile) {
  * dark-mode tokens readable. The theme follows the OS setting, so
  * emulateMedia switches it.
  */
-export function defineA11ySuite({ formRoutes, loggedOutRoutes }) {
+export function defineA11ySuite({ formRoutes, viewRoutes = [], loggedOutRoutes }) {
     for (const colorScheme of ['light', 'dark']) {
         test.describe(`accessibility (${colorScheme})`, () => {
             test.beforeEach(async ({ page }) => {
@@ -90,6 +90,14 @@ export function defineA11ySuite({ formRoutes, loggedOutRoutes }) {
                     await expectNoAxeViolations(page);
                 });
             }
+            for (const route of viewRoutes) {
+                test(`${route} has zero axe violations`, async ({ page }) => {
+                    await page.goto(route);
+                    // EntityView's loaded state, not its skeleton or an error.
+                    await expect(page.locator('[data-state="success"]')).toBeVisible();
+                    await expectNoAxeViolations(page);
+                });
+            }
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tristan2828/ui-foundation",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "description": "Shared UI foundation for contract-first, database-backed React apps: shadcn primitives, DataTable/EntityForm composites, auth, the gateway error seam, design tokens, lint rules and the AI playbook.",
   "license": "MIT",
   "repository": {
@@ -134,6 +134,8 @@
     "js-yaml": "^5.4.2",
     "lucide-react": "^1.47.0",
     "react-day-picker": "^10.0.1",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
     "shadcn": "^4.21.0",
     "tw-animate-css": "^1.4.0"
   },