@burojs/ui-shadcn 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -1,30 +1,29 @@
 import { t as THEME_STORAGE_KEY } from "./theme-storage-key-pYlp4aDS.js";
-import { ActionDensity, AppRuntime, Check, CheckSurface, CustomPageDef, Dispatcher, DocumentTemplate, EntityRef, ErasedResourceHandle, ExportArtifact, ExportTarget, FieldDeclaration, FieldLayoutSpec, FilterExpression, FilterGroup, FilterOperator, FixedFilterInput, HrefOpts, I18nCaps, LocalizedMessage, NavGroupDef, NavNode, PortableValue, ResolvedFixedFilter, ResourceDef, ResourceFieldMap, ResourceValidator, ResourceWizardDef, RouteMatch, SavedViewDef, SectionDef, SortExpression, StandardSchemaV1, TabView, TaskRunReport, UiSettingsIssue, ValidationIssues, ValueCodec, i18nPrefixToRef } from "@burojs/core";
-import { CheckGateState, FieldBinding, FieldImplementation, FieldPresentation, FilterFieldSpec, FilterKind, FormValues, RecentRecord, RowRecord, SavedViewEntry, UIPresentationHostProps, UIPresentationHosts, UseDeclarativeFormOptions, modeForSurface } from "@burojs/react";
+import { ActionDensity, AnyFrameHandle, AppRuntime, AuthResult, Check, CheckSurface, CustomPageDef, DraftOption, EntityRef, ErasedResourceHandle, ExportArtifact, ExportTarget, FieldDeclaration, FilterExpression, FilterGroup, FilterOperator, FixedFilterInput, FormBody, FrameHandle, HrefOpts, I18nCaps, NavGroupDef, NavNode, PortableValue, RelationOpen, ResolvedFixedFilter, ResourceDef, ResourceFieldMap, ResourceHandle, RouteMatch, SavedViewDef, ScreenMode, ScreenSources, SearchDecl, SectionDef, SortExpression, StandardSchemaV1, TaskRunReport, UiSettingsIssue, ValidationIssues, ValueCodec, i18nPrefixToRef } from "@burojs/core";
+import { BlockImplementationCatalog, CheckGateState, CollectionDisplayProps, CollectionInputProps, DEFAULT_LANGUAGE_STORAGE_KEY, FieldBinding, FieldImplementation, FieldImplementationLayout, FieldPresentation, FilterFieldSpec, FilterKind, FormValues, QuickSettledRow, RowRecord, SavedViewEntry, ScalarDisplayProps, ScalarInputProps, UIPresentationHostProps, UIPresentationHosts, UseFormControllerFormOptions, modeForSurface, useApp, useOptionalT, useTestIds } from "@burojs/react";
 import * as React$1 from "react";
-import { AnchorHTMLAttributes, Component as Component$1, ComponentType, JSX, ReactElement, ReactNode, SVGProps } from "react";
+import { AnchorHTMLAttributes, ComponentProps, ComponentType, JSX, ReactElement, ReactNode, SVGProps } from "react";
 import { ClassValue } from "clsx";
 import * as PopoverPrimitive from "@radix-ui/react-popover";
-import { Slot } from "@radix-ui/react-slot";
+import { Slot as Slot$1 } from "@radix-ui/react-slot";
 import { VariantProps } from "class-variance-authority";
 import { Command as Command$1 } from "cmdk";
 import * as DialogPrimitive from "@radix-ui/react-dialog";
 import * as SeparatorPrimitive from "@radix-ui/react-separator";
 import * as TooltipPrimitive from "@radix-ui/react-tooltip";
-import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
 import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
-import * as LabelPrimitive from "@radix-ui/react-label";
-import { ToasterProps as ToasterProps$1, toast } from "sonner";
-import * as SelectPrimitive from "@radix-ui/react-select";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
 import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+import { ToasterProps as ToasterProps$1, toast } from "sonner";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
 import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
 import { Column, ColumnDef, ColumnFiltersState, ColumnOrderState, ColumnPinningState, ColumnSizingState, OnChangeFn, PaginationState, Row, RowSelectionState, SortingState, Table as Table$1, Updater, VisibilityState } from "@tanstack/react-table";
-import { isImage } from "@burojs/file-storage";
-import * as AvatarPrimitive from "@radix-ui/react-avatar";
+import * as SelectPrimitive from "@radix-ui/react-select";
 import { ControllerProps, FieldPath, FieldValues } from "react-hook-form";
 import { z } from "zod";
-import * as TabsPrimitive from "@radix-ui/react-tabs";
-import { LocaleRegistry } from "@burojs/i18n-core";
+import { isImage } from "@burojs/file-storage";
 //#region src/doc/doc-info.d.ts
 interface DocInfoProps {
   /** Doc address, e.g. `document_document/fields/gtin`. */
@@ -188,7 +187,11 @@ declare function CommandPaletteDocsGroup({ locale, onSelect, heading }: CommandP
 //#region src/layout/app-layout.d.ts
 interface AppLayoutProps {
   children: ReactNode;
-  /** The sidebar tree — typically <AppSidebar .../>. */
+  /**
+   * The sidebar tree — typically <AppSidebar .../>. `null` (or `undefined`/`false`) means no
+   * sidebar at all: the layout then mounts no `SidebarProvider`, so `useOptionalSidebar()` is
+   * null below it and `AppHeader` drops its trigger.
+   */
   sidebar: ReactNode;
   /** The header tree — typically <AppHeader .../>. */
   header?: ReactNode;
@@ -212,56 +215,31 @@ interface AppLayoutProps {
  */
 declare function AppLayout({ children, sidebar, header, docPanel }: AppLayoutProps): React.ReactElement;
 //#endregion
+//#region src/shell/slot.d.ts
+/**
+ * A shell component's slot. Omit it (or pass `undefined`, which is the same
+ * thing) to get the component's default; pass `false` to leave the slot
+ * empty; pass anything else to replace the default with it. `null` is an
+ * element like any other: it replaces the default and renders nothing.
+ */
+type Slot = ReactNode | false;
+//#endregion
 //#region src/layout/app-sidebar.d.ts
+/** Every slot follows {@link Slot}: omit for the default, `false` for nothing, an element to replace. */
 interface AppSidebarProps {
-  /** Top of the sidebar — typically a company/workspace switcher. */
-  switcher?: ReactNode;
-  /** Scope filters rendered under the switcher (company-mode only). */
-  filters?: ReactNode;
-  /** Main navigation — usually <NavMain />. */
-  nav: ReactNode;
-  /** Footer — usually <NavUser />. */
-  footer?: ReactNode;
-}
-declare function AppSidebar({ switcher, filters, nav, footer }: AppSidebarProps): React.ReactElement;
-//#endregion
-//#region src/layout/sidebar.d.ts
-interface SidebarProps {
-  className?: string;
-  /** Current pathname for active-link highlight + aria-current. */
-  currentPath?: string;
-  /**
-   * Slot for context pickers (company switcher, product-group, location, etc.)
-   * Rendered between the app name and the resource nav links.
-   */
-  pickers?: ReactNode;
-  /** Slot for content rendered below the resource nav links (footer, version, etc.) */
-  footer?: ReactNode;
-  /**
-   * Optional static nav links rendered ABOVE the resource list (e.g. external
-   * URLs, conditional links). Consumer provides the JSX. For declarative
-   * registered pages, prefer `defineCustomPage` + `app.use(...)` — those are
-   * auto-rendered between this slot and the Resources header. The two
-   * coexist so adopters can migrate incrementally.
-   */
-  topNav?: ReactNode;
-  /**
-   * Optional icon resolver invoked for each resource link. Returns a
-   * ReactNode (typically a Tabler icon at `h-4 w-4`) rendered to
-   * the LEFT of the resource label, mirroring the iar-ui sidebar
-   * pattern. Returning `undefined` for a particular resource is fine —
-   * that link renders without an icon. The whole prop is optional;
-   * adopters who don't supply it get the legacy text-only sidebar.
-   */
-  iconForResource?: (def: ResourceDef) => ReactNode;
-  /** Same as `iconForResource` but for custom pages (top-level + sectioned). */
-  iconForCustomPage?: (def: CustomPageDef) => ReactNode;
+  /** Top of the sidebar. Default `<SidebarBrand />` (the `ShellProvider` brand). */
+  header?: Slot;
+  /** Scope filters rendered under the header. No default. */
+  filters?: Slot;
+  /** Main navigation. Default `<NavMain />`. */
+  nav?: Slot;
+  /** Footer. Default `<UserMenu />`, which renders nothing without an auth provider. */
+  footer?: Slot;
 }
-declare function Sidebar({ className, currentPath, pickers, footer, topNav, iconForResource, iconForCustomPage }: SidebarProps): React.ReactElement;
+declare function AppSidebar({ header, filters, nav, footer }: AppSidebarProps): React.ReactElement;
 //#endregion
 //#region src/layout/nav-main.d.ts
 interface NavMainProps {
-  currentPath?: string;
   iconForResource?: (def: ResourceDef) => ReactNode;
   iconForCustomPage?: (def: CustomPageDef) => ReactNode;
   /** Icon for a collapsible section's trigger row (#16). */
@@ -287,7 +265,67 @@ interface NavMainProps {
    */
   topLabel?: string | null;
 }
-declare function NavMain({ topLabel, currentPath, iconForResource, iconForCustomPage, iconForSection, entryFilter }: NavMainProps): React.ReactElement;
+declare function NavMain({ topLabel, iconForResource, iconForCustomPage, iconForSection, entryFilter }: NavMainProps): React.ReactElement;
+//#endregion
+//#region src/layout/use-nav-tree.d.ts
+/**
+ * How a group presents its children. `flat` and `collapsible` expand inline in
+ * the sidebar; any other value is the key of a registered content layout
+ * (`tabs`, `secondary-sidebar`, or an app's own), and the sidebar shows the
+ * group as ONE link into its area.
+ */
+type NavTreeLayout = 'flat' | 'collapsible' | 'tabs' | 'secondary-sidebar' | (string & {});
+/** One navigable entry. `icon` is the declared icon NAME; the renderer resolves it. */
+type NavTreeEntry = {
+  kind: 'resource' | 'page';
+  key: string;
+  label: string;
+  href: string;
+  icon?: string;
+  active: boolean;
+} | {
+  kind: 'group';
+  key: string;
+  label: string;
+  href?: string;
+  icon?: string;
+  /** For a content group: its link is the current location. Otherwise: an ancestor of it. */
+  active: boolean;
+  layout: NavTreeLayout;
+  /** Declared `defaultOpen`, or the active page lives inside. */
+  defaultOpen: boolean;
+  children: NavTreeEntry[];
+};
+/**
+ * One block of the sidebar. The first block is the ungrouped top level, with
+ * `key: null` and `label: null`: the renderer decides its heading. A block with
+ * a key and `label: null` is a content group's own link and has no heading.
+ */
+interface NavTreeSection {
+  key: string | null;
+  label: string | null;
+  icon?: string;
+  collapsible: boolean;
+  /** Open on first render: declared `defaultOpen`, or `active`. */
+  defaultOpen: boolean;
+  /** One of the entries is the page currently shown. Drives re-opening a collapsed block. */
+  active: boolean;
+  entries: NavTreeEntry[];
+}
+interface UseNavTreeOptions {
+  /**
+   * Extra allow-filter applied to every nav entry (resources, custom pages and
+   * groups) on top of the built-in visibility rules. Return false to hide an
+   * entry. Defaults to always-true.
+   */
+  entryFilter?: (entry: NavNode) => boolean;
+}
+/**
+ * The sidebar's navigation as plain data: what `<NavMain>` draws, with every
+ * visibility rule, permission gate, sort, label and active flag already
+ * applied. Build a custom nav on it and it shows the same entries.
+ */
+declare function useNavTree(opts?: UseNavTreeOptions): NavTreeSection[];
 //#endregion
 //#region src/layout/nav-slots.d.ts
 /** A resolved child entry a layout renderer draws (spec §8.2). */
@@ -308,33 +346,10 @@ interface NavLayoutProps {
   children: ReactNode;
 }
 type NavLayout = ComponentType<NavLayoutProps>;
-/** Components-registry slot key for a layout renderer. */
+/** Components-registry slot key for a layout renderer: `layout.<key>`. */
 declare function layoutSlot(key: string): string;
-/** Components-registry slot key for a custom page's component. */
-declare function pageSlot(name: string): string;
-/**
- * Components-registry slot key for a `kind: 'component'` tab's body.
- *
- * The declaration and the registration have to name the SAME slot, and until
- * this existed both sides hand-wrote the `'tab.'` prefix — which is how two
- * conventions ended up in the wild (a bare component name, and a full
- * `'tab.…'` key) and why `DetailTabsShell` normalises them. Passing this
- * function's result on both sides makes the two agree by construction:
- *
- * ```ts
- * tabs: [{ kind: 'component', key: 'history', component: tabSlot('document-history') }]
- * components: { [tabSlot('document-history')]: DocumentHistoryTab }
- * ```
- *
- * Idempotent, so `tabSlot(tabSlot('x'))` is `tabSlot('x')` — the shell accepts
- * an already-prefixed key and so does this, rather than producing `tab.tab.x`
- * for an adopter migrating a hand-written literal.
- */
-declare function tabSlot(name: string): string;
 /** Resolve the registered layout renderer for a `layout` slot key, or undefined. */
 declare function useLayout(key: string): NavLayout | undefined;
-/** Resolve the registered component for a custom page, or undefined. */
-declare function usePageComponent(name: string): ComponentType<Record<string, never>> | undefined;
 /**
  * Non-hook-in-loop layout lookup: read the Components registry once, return a
  * resolver `(key) => NavLayout | undefined`. Lets `NavChrome` resolve a
@@ -446,59 +461,166 @@ interface ResourcePageRouterProps {
 }
 /**
  * Dispatch a resolved `RouteMatch` (from `matchPath`/`useMatch`) to the
- * framework component that renders it.
- *
- * ⚠️ **Scope, precisely** (core-flexibility Task B3.3 — read this before
- * trusting any branch without checking). Of the dispatch sites below, only
- * THREE are data-connected; the rest are stubs. Treating "renders
- * something" as "renders live data" here is exactly what let this
- * component's `list` branch render a permanent empty state for the whole
- * length of this program while looking, from the outside, like it worked.
- *
- * REAL — data-connected via `<ResourceListPage>` (self-fetches through
- * `useResourceList`; no `data` prop needed):
- *  - `{ kind: 'resource', action: 'list' }`.
- *  - `{ kind: 'group-index' }` falling back to a list — no page registered
- *    for the group's index target, but the target IS a registered
- *    resource (first-descendant fallback).
- *
- * There used to be a third entry here, `{ kind: 'singleton' }`, and it was
- * DEAD both ways: `matchPath` never produced that kind, so neither half of
- * the branch was reachable outside this file's own hand-built matches, and
- * the half that "worked" rendered the stub `<ResourceEdit>` below against a
- * constant record id. Both it and `ResourceConfig.singleton` are gone — read
- * that type for what a one-row screen is expressed with instead.
- *
- * STILL STUBS — framework GLUE, not data-connected:
- *  - `show`, `edit`, `create`/`create-wizard`.
- *  `ResourceShow`/`ResourceEdit`/`ResourceCreate` are prop-driven: they
- *  take an already-loaded `record` and `onSave`/`onCreate` callbacks
- *  rather than fetching anything themselves (data fetching is the HOST's
- *  job — see the demo app's Next.js app-router pages for the
- *  connected pattern). This router has no data provider to draw on for
- *  these matches, so it renders the MINIMAL props derivable from the
- *  match alone: a stub `record={{ id }}` and no-op save/create callbacks.
- *  A host that wants live data for these routes should render its own
- *  connected page instead of (or on top of) `<ResourcePageRouter>` — see
- *  the playground's `_nav-area-page.tsx`, written for exactly that reason
- *  (predating `<ResourceListPage>`, and — per its own dispatcher — still
- *  necessary: it feeds the list page an app-level query `meta` and a
- *  `renderCell` this generic router has no way to know about).
- *
- * `custom-page`, and `group-index` when a page IS registered, render
- * whatever the adopter registered for that slot — they own their own data
- * by construction, so "real vs. stub" does not apply to them.
+ * framework component that renders it. Every branch is data-connected:
+ *
+ *  - `{ kind: 'resource', action: 'list' }` → `<ResourceListPage>`, which
+ *    self-fetches through `useResourceList`;
+ *  - `show`, `edit` and `create` → `<RecordRoute>` (the
+ *    component `<RecordPage>` renders), which reads with `useOne`, writes with
+ *    `useUpdateOne`/`useCreateOne`, navigates after a write and renders the
+ *    record states, breadcrumbs and `?tab=`. A record route whose operation
+ *    the resource turned off (`operations.show: false`, …) renders the
+ *    not-found panel;
+ *  - `{ kind: 'group-index' }` → the group's index page when it has a
+ *    `body`, else that target's list when it is a resource;
+ *  - `custom-page` → the page's `body` behind the nav gate (`<PageHost>`: a
+ *    page whose `visible` or whose group's `visible` rejects it renders
+ *    not-found and mounts nothing); a page without `body` renders not-found,
+ *    because the host owns that route.
+ *
+ * A record route always renders the framework's record page: a different layout is a frame on
+ * the screen (`views.<mode>.frame`), never a replaced route (P6-56).
  */
 declare function ResourcePageRouter({ match }: ResourcePageRouterProps): ReactElement;
 /**
- * Resolves the active route (`useMatch`) and renders it inside the group-
- * chain chrome (`NavChrome`), dispatching to the right framework component
- * via `ResourcePageRouter`. No match → a not-found panel. Wrapped in a
- * `Suspense` boundary so a lazily-loaded custom page (`React.lazy`) degrades
- * to a skeleton inside the chrome instead of blowing past it.
+ * Resolves the active route (`useMatch`, from the router adapter) and renders
+ * it inside the group-chain chrome (`NavChrome`), dispatching to the right
+ * framework component via `ResourcePageRouter`. No match → a not-found panel;
+ * no router adapter at all → the same panel, and in development one
+ * `console.error` naming `RouterAdapterProvider` (once per app), because
+ * then EVERY route is not-found. Wrapped in a `Suspense` boundary so a
+ * lazily-loaded custom page (`React.lazy`) degrades to a skeleton inside the
+ * chrome.
  */
 declare function NavAreaPage(): ReactElement;
 //#endregion
+//#region src/layout/record-page.d.ts
+/**
+ * A record page's resource and action. Inside a record slot both default to
+ * the route (`<RecordPage defaults={{ type }} />`); outside one both are
+ * required, and a missing one renders not-found with a development error.
+ * `defaults` exists on `create` only: show and edit render the record as it
+ * is, so the type refuses it there rather than ignoring it.
+ */
+type RecordPageProps = {
+  readonly resource?: string;
+  readonly action: Exclude<ScreenMode, 'create'>;
+  readonly defaults?: never;
+} | {
+  readonly resource?: string;
+  readonly action?: Extract<ScreenMode, 'create'>;
+  /**
+   * The caller's tier of starting values, above each field's declared
+   * default, the matched type's `defaults` and URL prefill.
+   */
+  readonly defaults?: Record<string, unknown>;
+};
+/**
+ * The record page — show, edit or create — wired to data. It reads the id
+ * and the group chain from the current route match, reads with `useOne`,
+ * renders the record through `<RecordScreen>` (which writes with the
+ * resource's update or create), navigates after a write (show when the
+ * resource has one, else the list), and renders translated loading,
+ * not-found, session-expired and error states. It draws no breadcrumb trail:
+ * the header's `<HeaderBreadcrumbs>` does, and shows the record's title once
+ * this page has loaded it (the id until then). The open panel of a keyed tabs node lives in the URL as `?<tabsKey>=<panelKey>`.
+ *
+ * `<ResourcePageRouter>` renders the record route itself; a different layout is a frame on the
+ * screen (`views.<mode>.frame`), never a replaced route (P6-56).
+ */
+declare function RecordPage(props: RecordPageProps): ReactElement;
+//#endregion
+//#region src/layout/record-breadcrumbs.d.ts
+/**
+ * The record trail of the current route, the one `<HeaderBreadcrumbs>` draws
+ * there; record and flow pages draw none of their own.
+ *
+ * On a record route whose operation is available: the group chain, the
+ * resource, then the record (show), the record linking to show when show is
+ * available plus "Edit" (edit), or "Create" (create). The record crumb is the
+ * record's title once `<RecordPage>` has loaded it, and the id while it loads,
+ * has failed, or is not mounted at all.
+ *
+ * On a page-hosted flow's route: the record's edit-shaped trail ending with the
+ * flow's label, once the flow page shows its form or its "not available"
+ * notice; until then, and on every not-found it answers with, the record's
+ * show trail with the id, so a flow the user may not run is never named. A
+ * name no flow answers to is the framework 404, with no trail.
+ *
+ * Nothing on any other route.
+ */
+declare function RecordBreadcrumbs(): ReactElement | null;
+//#endregion
+//#region src/record/record-screen.d.ts
+type AnyResourceHandle = ResourceHandle<any, any, any, any>;
+interface RecordScreenProps {
+  /** A canonical resource name, or its handle. */
+  readonly resource: string | AnyResourceHandle;
+  readonly mode: 'show' | 'edit' | 'create';
+  /** The record to read (show, edit); not needed when `record` is given. */
+  readonly recordId?: string;
+  /**
+   * The accepted type of a typed create. Without a router, changing it remounts the form for the
+   * new type and discards unsaved input without asking for confirmation.
+   */
+  readonly type?: string;
+  /** A row the caller already holds: nothing is read. */
+  readonly record?: Readonly<Record<string, unknown>>;
+  /** The caller's starting values of a create, above the field defaults. */
+  readonly defaults?: Readonly<Record<string, unknown>>;
+  /**
+   * User input for a create (a search text typed into a relation select): after the first settled
+   * plan each key whose field the plan holds `active` is set once, as the user typing it would
+   * (the form is dirty); any other key is dropped. Not a default, never trusted.
+   */
+  readonly input?: Readonly<Record<string, unknown>>;
+  /** Replaces the built-in update or create; receives the payload. */
+  readonly onSubmit?: (payload: Record<string, unknown>) => Promise<unknown>;
+  /** Called after a successful submit with what the write returned. */
+  readonly onSuccess?: (result: unknown) => void;
+  /** Replaces Cancel's default back navigation. */
+  readonly onCancel?: () => void;
+  /** The submit button's label. */
+  readonly submitLabel?: string;
+  /** Rendered after the record's actions in show. */
+  readonly extraActions?: ReactNode;
+  /**
+   * This instance's record frame (code only): used when its slots cover every slot the screen
+   * fills, else a development error and the screen's own frame (spec 3.3).
+   */
+  readonly frame?: FrameHandle<'record'> | AnyFrameHandle;
+}
+/**
+ * A record's show, edit or create screen outside a route (P1b+P1c decision
+ * 20): the planned screen in its frame (the screen's, the app's, the built-in
+ * one, or this instance's `frame`). Reads the record by `recordId` unless
+ * `record` is given; writes with the resource's update or create unless
+ * `onSubmit` is given. A resource the app does not know renders not-found.
+ */
+declare function RecordScreen(props: RecordScreenProps): ReactElement;
+//#endregion
+//#region src/record/frame-pieces.d.ts
+/**
+ * The record's title: its `recordTitle` / display field (show, edit), or
+ * "Create <label>" in create. Inside `<RecordScreen>` only; no props.
+ */
+declare const RecordTitle: () => ReactElement | null;
+/**
+ * The record's item actions: the resolved `<ActionOverflow>` of the mode's
+ * surface, then `<RecordScreen extraActions>`. Nothing in create or before
+ * the record is read.
+ */
+declare const RecordActions: () => ReactElement | null;
+/** Copies the record's id to the clipboard. Nothing without an id (create). */
+declare const CopyId: () => ReactElement | null;
+/**
+ * Submit and Cancel (edit, create): Submit runs the controller's submit and
+ * then `onSuccess`; Cancel calls `onCancel`, else navigates back through the
+ * navigation guard. Above them, the form-level messages and a failed write.
+ * Nothing in show.
+ */
+declare const FormActions: () => ReactElement | null;
+//#endregion
 //#region src/layout/default-nav-layouts.d.ts
 /** The built-in content-wrapping layouts. Merge into the app's Components registry. */
 declare const defaultNavLayouts: Record<string, NavLayout>;
@@ -545,6 +667,8 @@ declare function ContextPicker({ sliceName, label, options, value, onChange, pla
 /** What the user picked. `'system'` means "no explicit choice" — nothing is
  * persisted for it; its absence from storage IS the `system` state. */
 type ThemeChoice = 'light' | 'dark' | 'system';
+/** Every theme choice, in the order a control offers them. */
+declare const THEME_CHOICES: readonly ThemeChoice[];
 /** What is actually painted. Never `'system'` — every reader (Toaster,
  * CodeMirror, Mermaid) only ever needs to know light or dark. */
 type ResolvedTheme = 'light' | 'dark';
@@ -590,14 +714,28 @@ interface UseThemeResult {
 declare function useTheme(): UseThemeResult;
 //#endregion
 //#region src/layout/language-switch.d.ts
+interface LanguageSwitchProps {
+  /**
+   * Called with the picked locale code AFTER the live locale has switched and
+   * the choice has been persisted.
+   */
+  onChange?: (code: string) => void;
+  className?: string;
+}
 /**
- * Default localStorage key. Framework-neutral so multiple adopters on
- * the same domain don't collide. Override per-app via the `storageKey`
- * prop on `<LanguageSwitch>` and the matching arg on `loadLocale(key)` /
- * `saveLocale(key, code)` (or the legacy `loadLanguage`/`saveLanguage` pair
- * below).
+ * Segmented locale switcher: one button per locale the i18n facade lists
+ * (`I18nFacade.locales`, which `createI18nFromRegistry` fills from the
+ * registry), each labelled with the locale's own name (`Intl.DisplayNames`).
+ * A view over {@link useLanguageSwitch}: picking a locale switches the LIVE
+ * locale (no reload) and persists it under `<BuroProvider languageStorageKey>`.
+ *
+ * Reactivity: the active locale is read live, so the switcher always reflects
+ * the CURRENT locale, including a change made elsewhere. `tests/language-switch.test.tsx`
+ * guards that nothing here reloads the page.
  */
-declare const DEFAULT_LANGUAGE_STORAGE_KEY = "buro:language";
+declare function LanguageSwitch({ onChange, className }: LanguageSwitchProps): React.ReactElement;
+//#endregion
+//#region src/layout/language-storage.d.ts
 /**
  * Legacy RU/EN-only pair. `<LanguageSwitch>` itself no longer uses these —
  * see its own docblock. New code that needs an arbitrary (not just 'en'/'ru')
@@ -669,142 +807,81 @@ declare function saveLanguage(code: LanguageCode, storageKey?: string): void;
 declare function loadLocale(storageKey?: string): string | undefined;
 /** Persist an arbitrary locale code. Generic counterpart to {@link saveLanguage}. */
 declare function saveLocale(code: string, storageKey?: string): void;
-interface LanguageSwitchProps {
-  /**
-   * The locale registry to build the switcher from. `registry.locales()`
-   * is the ENTIRE set of buttons rendered — there is no separate list to
-   * keep in sync, and no literal locale code anywhere in this component.
-   * Adding a locale to the registry (a new contribution — see
-   * `@burojs/i18n-core`'s `LocaleRegistry`) is the whole mechanism for it to
-   * appear here.
-   */
-  registry: LocaleRegistry;
-  /**
-   * Namespace to read each locale's `nav.languageName` display name from
-   * (see {@link localeDisplayName}). Defaults to `'common'` — the same
-   * default namespace `LocaleRegistry` itself uses.
-   */
-  namespace?: string;
-  className?: string;
-  /**
-   * localStorage key to persist the chosen locale under via
-   * {@link saveLocale}. Defaults to `buro:language`.
-   */
-  storageKey?: string;
-  /**
-   * Called AFTER the locale is persisted to localStorage, INSTEAD of the
-   * default live-switch behavior. Pass this if your app needs to do
-   * something else on a language change (re-key a provider tree, push a
-   * route); omit it to get the default: switch the live locale via
-   * `useChangeLocale()`, no reload.
-   */
-  onChange?: (code: string) => void;
-}
-/**
- * Locale switcher built entirely from a {@link LocaleRegistry} — any number
- * of locales, not a fixed pair. A segmented control with one button per
- * `registry.locales()` entry.
- *
- * Reactivity: the active locale is read live via `useLocale()`
- * (`useSyncExternalStore` under the i18n facade's `onLocaleChange`), so this
- * component always reflects the CURRENT locale, including a change made
- * elsewhere (another switcher instance, a deep link, etc.) — there is no
- * local "current" state to fall out of sync. Picking a locale persists the
- * choice via `saveLocale` and switches the LIVE locale via
- * `useChangeLocale()` — no reload. Adopters who need to do something else
- * pass `onChange`, which takes over entirely.
- *
- * ⚠️ The two-button predecessor of this component used to reload the page on
- * every pick, and its docblock used to justify that as necessary because
- * "resource labels and the framework's built-in strings are consumed at
- * provider-boot registration time." That was true at v0.1 and is not true
- * now — the i18n content model made every label render-time. Nothing here
- * should reintroduce a reload; `tests/language-switch.test.tsx` guards it.
- */
-declare function LanguageSwitch({ registry, namespace, className, storageKey, onChange }: LanguageSwitchProps): React.ReactElement;
 //#endregion
 //#region src/layout/breadcrumbs.d.ts
-interface BreadcrumbsProps {
+type Segment = {
+  label: string;
+  href?: string;
+};
+interface BreadcrumbsBaseProps {
+  className?: string;
   /**
-   * Resource name (matches the registry key). When omitted the
-   * component falls back to `useCurrentResource()` — which only
-   * resolves when a `ResourceContext.Provider` wraps the tree
-   * (currently set in tests only). Pass `resource` explicitly from
-   * resource-aware renderers like `<ResourceShow>` so the breadcrumb
-   * works in production code paths that don't (yet) provide the
-   * context.
+   * Scopes the trail offers help for, outermost first. Defaults to the resource
+   * this breadcrumb is rooted at (none for a trail without a resource).
    */
-  resource?: string;
+  docScopes?: string[];
   /**
-   * Identifier for the current page (for testid only — display label
-   * comes from `pageLabel`). Typical use: a record id on show/edit
-   * pages.
+   * Segments rendered before the resource segment (or before the page label in
+   * a trail without one), each followed by a chevron — the group chain. A
+   * segment with an `href` renders as a link; without one, as muted text.
    */
+  leadingSegments?: Segment[];
+  /** Optional testid forwarded to the root nav. */
+  'data-testid'?: string;
+}
+/** A trail that ends at, or passes through, a resource: its list link, then the record. */
+interface ResourceBreadcrumbsProps extends BreadcrumbsBaseProps {
+  /** Resource name (the registry key). */
+  resource: string;
+  name?: never;
+  /** Identifier for the current page (testid only); a record id on show/edit pages. */
   recordId?: string;
   /**
-   * Display label for the trailing breadcrumb segment (the current
-   * page). When omitted, only the resource segment is rendered —
-   * useful when the breadcrumb sits next to a page title that
-   * already names the record.
+   * Display label for the trailing segment (the current page). When omitted
+   * the resource segment itself is the current crumb (a list page).
    */
   pageLabel?: string;
-  className?: string;
-  /**
-   * Scopes the trail offers help for, outermost first. Defaults to the resource
-   * this breadcrumb is rooted at. Pass a longer list when the trail crosses
-   * several documented resources — the control then offers all of them, which
-   * is the thing a per-entity icon structurally cannot do.
-   */
-  docScopes?: string[];
   /**
-   * Optional segments rendered BEFORE the resource segment (each followed by a
-   * chevron). Use for a grouping prefix such as a sidebar-section label — e.g.
-   * a per-type document detail page roots its breadcrumb at
-   * `Документы по типу › Заказы на производство › #id`. A segment with an `href`
-   * renders as a link; without one it renders as muted static text. Undefined
-   * (the default) → the breadcrumb starts at the resource segment, unchanged.
+   * Segments rendered between the resource link and the trailing page label —
+   * the record on an edit page («Documents › live-one › Edit»). A segment
+   * without `href` renders as plain text.
    */
-  leadingSegments?: Array<{
-    label: string;
-    href?: string;
-  }>;
-  /**
-   * Segments rendered BETWEEN the resource link and the trailing page label.
-   *
-   * `leadingSegments` sits ABOVE the resource (a section), which is wrong for
-   * anything that belongs to it — putting the record there produced
-   * «live-one › Документы › Изменение». An edit page needs
-   * «Документы › live-one › Изменение», i.e. the record nested under its
-   * resource. A segment without `href` renders as plain text, for records whose
-   * resource has no standalone show page.
-   */
-  middleSegments?: Array<{
-    label: string;
-    href?: string;
-  }>;
-  /** Optional testid forwarded to the root nav. */
-  'data-testid'?: string;
+  middleSegments?: Segment[];
 }
+/** A trail with no resource segment: a custom page or a group index. */
+interface PageBreadcrumbsProps extends BreadcrumbsBaseProps {
+  resource?: never;
+  /** The test-id name of the current crumb: the custom page's or the group's key. */
+  name: string;
+  /** The current page's label, the trail's last crumb. */
+  pageLabel: string;
+  recordId?: never;
+  middleSegments?: never;
+}
+type BreadcrumbsProps = ResourceBreadcrumbsProps | PageBreadcrumbsProps;
+/**
+ * The navigation breadcrumb, in two shapes. With `resource`: the leading
+ * segments, the resource (a link to its canonical, nesting-aware list href,
+ * or the current crumb on a bare list), the middle segments and the page
+ * label. Without: the leading segments and the page label only, test ids
+ * named by `name`. The last crumb is always the "you are here" marker — an
+ * emphasised, non-linked span with `aria-current="page"`. Every crumb carries
+ * its label as a `title` tooltip, so a truncated one can still be read.
+ */
+declare function Breadcrumbs(props: BreadcrumbsProps): ReactElement | null;
+//#endregion
+//#region src/layout/header-breadcrumbs.d.ts
 /**
- * Compact navigation breadcrumb for resource detail pages. Adapts the
- * canonical shadcn `Breadcrumb` pattern onto our existing `<a>` +
- * Tabler primitives — we don't ship the full
- * `Breadcrumb`/`BreadcrumbList`/`BreadcrumbPage` factory because the
- * admin breadcrumb is always a 1- or 2-segment shape (resource → page)
- * keyed off the registry's current resource. Adopters that need
- * deeper hierarchies can compose `<a>` + `<IconChevronRight>` directly.
- *
- * Resource segment links to the canonical `hrefFor(registry, def.name)`
- * (nesting-aware — resolves to a group-prefixed path for grouped resources).
- * Trailing
- * `pageLabel` segment renders as a non-link `<span>` to mark "you
- * are here". Resource label resolves to
- * `def.label?.plural ?? humanizeKey(def.name)` so registered labels
- * propagate naturally — the prior implementation showed the raw
- * resource id which read poorly for resources like
- * `reference_locations`.
- */
-declare function Breadcrumbs({ resource, recordId, pageLabel, leadingSegments, middleSegments, className, docScopes, 'data-testid': testId }: BreadcrumbsProps): React.ReactElement | null;
+ * The page's one breadcrumb trail, and `<AppHeader>`'s default `breadcrumbs`:
+ * the group chain and the resource, custom page or group — and on a record
+ * route or a page-hosted flow's route the record trail (`<RecordBreadcrumbs>`,
+ * `data-testid="record-breadcrumbs"`), which ends with the record's title once
+ * the page has loaded it. Record and flow pages draw no trail of their own, so
+ * a page never shows two. Nothing — silently — without a match: a sidebar or
+ * header rendered in a story with no router is not a misconfiguration, and
+ * `<NavAreaPage>`'s own message is the one that names the fix.
+ */
+declare function HeaderBreadcrumbs(): ReactElement | null;
 //#endregion
 //#region src/layout/command-palette.d.ts
 /**
@@ -860,11 +937,14 @@ declare function CommandPalette({ open, onOpenChange, children, placeholder, emp
 //#endregion
 //#region src/layout/command-palette-trigger.d.ts
 interface CommandPaletteTriggerProps {
-  /** Opens the palette. Wire to `useCommandPalette().setOpen(true)`. */
-  onOpen: () => void;
+  /**
+   * Opens the palette. Defaults to the `ShellProvider`'s `openPalette`; with
+   * neither, the trigger renders nothing.
+   */
+  onOpen?: () => void;
   /** Shortcut hint rendered in the `<kbd>` chip. Defaults to `⌘K`. */
   shortcut?: string;
-  /** `data-testid` for the trigger button. */
+  /** `data-testid` for the trigger button. Default `'open-palette'`. */
   testid?: string;
   className?: string;
 }
@@ -877,7 +957,7 @@ interface CommandPaletteTriggerProps {
  * (`commandPalette.trigger` / `.triggerHint`) instead of hardcoded English.
  * Falls back to English when rendered outside a `BuroProvider`.
  */
-declare function CommandPaletteTrigger({ onOpen, shortcut, testid, className }: CommandPaletteTriggerProps): React.ReactElement;
+declare function CommandPaletteTrigger({ onOpen, shortcut, testid, className }: CommandPaletteTriggerProps): React.ReactElement | null;
 //#endregion
 //#region src/layout/command-palette-navigation-groups.d.ts
 /**
@@ -902,24 +982,14 @@ type CommandPaletteNavigationTestIdRole = 'resource' | 'page' | 'section' | 'gro
  * `useVisibilityCtx()` (mirrors the sidebar's filter logic so an entry
  * hidden in the sidebar stays hidden in the palette).
  *
- * Navigation is router-agnostic: adopters pass a `navigate` callback
- * (typically `(href) => router.push(href)` from their app router). When
- * omitted, the component falls back to a full-document navigation via
- * `window.location.assign(href)` so it remains usable outside Next /
- * react-router shells; SPA shells should always supply `navigate` to
- * keep client-side routing intact.
+ * Navigation goes through `useRouteNavigate` — the `RouterAdapter` the host
+ * mounts above `<BuroProvider>` — so picks stay client-side with nothing to
+ * wire.
  */
 interface CommandPaletteNavigationGroupsProps {
   /**
-   * Called to navigate to the picked entry's `href`. Wire this to your
-   * app router (`router.push` for Next App Router, `navigate(to)` for
-   * react-router, etc.). Optional — when omitted the component falls
-   * back to `window.location.assign(href)` (full reload).
-   */
-  navigate?: (href: string) => void;
-  /**
-   * Called after the user picks a navigation entry, BEFORE `navigate`
-   * fires. Adopters typically wire this to `setOpen(false)` to close
+   * Called after the user picks a navigation entry, BEFORE the
+   * navigation. Adopters typically wire this to `setOpen(false)` to close
    * the palette before the route change. Optional.
    */
   onSelect?: () => void;
@@ -939,7 +1009,7 @@ interface CommandPaletteNavigationGroupsProps {
  *
  * Visibility filtering mirrors `<Sidebar>` (visible predicates evaluated
  * against `useVisibilityCtx()`, fail-closed for throwing predicates,
- * embedded subresources hidden from navigation entirely). An entry hidden
+ * resources with no list page hidden from navigation entirely). An entry hidden
  * in the sidebar is also hidden in the palette — that parity is the
  * primary contract of this component.
  *
@@ -967,7 +1037,6 @@ interface CommandPaletteNavigationGroupsProps {
  *
  * ```tsx
  * 'use client';
- * import { useRouter } from 'next/navigation';
  * import { useCommandPalette } from '@burojs/react';
  * import {
  *   CommandPalette,
@@ -975,12 +1044,10 @@ interface CommandPaletteNavigationGroupsProps {
  * } from '@burojs/ui-shadcn';
  *
  * function Shell() {
- *   const router = useRouter();
  *   const { open, setOpen } = useCommandPalette();
  *   return (
  *     <CommandPalette open={open} onOpenChange={setOpen}>
  *       <CommandPaletteNavigationGroups
- *         navigate={(href) => router.push(href)}
  *         onSelect={() => setOpen(false)}
  *       />
  *     </CommandPalette>
@@ -988,7 +1055,7 @@ interface CommandPaletteNavigationGroupsProps {
  * }
  * ```
  */
-declare function CommandPaletteNavigationGroups({ navigate, onSelect, getTestId }: CommandPaletteNavigationGroupsProps): React.ReactElement | null;
+declare function CommandPaletteNavigationGroups({ onSelect, getTestId }: CommandPaletteNavigationGroupsProps): React.ReactElement | null;
 //#endregion
 //#region src/layout/command-palette-recent-group.d.ts
 /**
@@ -996,35 +1063,21 @@ declare function CommandPaletteNavigationGroups({ navigate, onSelect, getTestId
  * `useTestIds` pattern used by `<CommandPaletteNavigationGroups>`.
  *
  * - `recent` — a recently-visited record entry. `id` passed to the
- *   builder is `<resource>:<record-id>`.
+ *   builder is `<canonical resource>:<record-id>`.
  */
 type CommandPaletteRecentTestIdRole = 'recent';
 /**
  * Props for `<CommandPaletteRecentGroup>`.
  *
- * The component reads the recent list from `localStorage` (via
- * `getRecentRecords`) and renders one `<CommandItem>` per entry. It
- * re-reads on every mount + whenever its `userId` prop changes —
- * single-tab consistency is preserved because the palette dialog
- * tears down + remounts each time it opens.
+ * The component reads the signed-in user's recent list (the records
+ * `<RecordPage>` recorded as it read them) and renders one `<CommandItem>`
+ * per entry. It re-reads on every mount, when the user changes and when
+ * `refreshKey` changes — single-tab consistency is preserved because the
+ * palette dialog tears down + remounts each time it opens.
  */
 interface CommandPaletteRecentGroupProps {
   /**
-   * Caller-supplied user id. Multi-user installs pass `auth.user?.id`;
-   * single-user / unauthenticated adopters omit and share a `'singleton'`
-   * bucket. The list is keyed by user so signing out + back in as a
-   * different user doesn't leak the previous user's history.
-   */
-  userId?: string | null;
-  /**
-   * Called to navigate to the picked record's URL. Wire this to your
-   * app router (`router.push` for Next App Router, `navigate(to)` for
-   * react-router, etc.). Optional — when omitted the component falls
-   * back to `window.location.assign(href)` (full reload).
-   */
-  navigate?: (href: string) => void;
-  /**
-   * Called BEFORE `navigate` fires. Adopters typically wire this to
+   * Called BEFORE the navigation. Adopters typically wire this to
    * `setOpen(false)` to close the palette during the route change.
    */
   onSelect?: () => void;
@@ -1039,17 +1092,11 @@ interface CommandPaletteRecentGroupProps {
    * explicit string to override.
    */
   heading?: string;
-  /**
-   * Override the path generator. By default the component navigates
-   * to `/<resource>/<id>` — adopters with custom routes (e.g. nested
-   * subresources) can override.
-   */
-  recordHref?: (entry: RecentRecord) => string;
   /**
    * Re-read trigger. When this prop changes the component re-reads
    * `localStorage` (e.g. flip from `false` → `true` on palette open).
-   * Optional — when omitted the component reads only on mount /
-   * `userId` change, which is sufficient for the typical "palette
+   * Optional — when omitted the component reads only on mount and when
+   * the user changes, which is sufficient for the typical "palette
    * dialog re-mounts on each open" use case.
    */
   refreshKey?: unknown;
@@ -1063,10 +1110,10 @@ interface CommandPaletteRecentGroupProps {
   withSeparator?: boolean;
 }
 /**
- * Render the "Recent" group inside a command palette: the last N
- * record-show URLs the current user visited, populated by adopter
- * code calling `useTrackRecentRecord(resource, record)` on the
- * record show / edit pages.
+ * Render the "Recent" group inside a command palette: the last records the
+ * signed-in user opened. `<RecordPage>` records each show or edit visit
+ * from the record it read — there is nothing to wire, and nothing is
+ * recorded or shown without a signed-in user.
  *
  * Visibility:
  *
@@ -1074,18 +1121,18 @@ interface CommandPaletteRecentGroupProps {
  *   "Recent" heading on a fresh user). Adopters that want a permanent
  *   slot (with an empty-state row) can fork this component — the
  *   surface is small.
- * - Resource label resolution: looks up the entry's `resource` in
- *   `app.registry`, falls back to `humanizeKey(resource)` if the
- *   resource has been deleted from the registry. The recent entry
- *   still navigates — server-side 404 is the user's signal that the
- *   record / resource is gone.
+ * - An entry opens the record's show route, else its edit route, built
+ *   from the registry. An entry whose resource the registry no longer
+ *   has, whose resource's `visible` now hides it from the user, or which
+ *   has neither route, is not rendered.
  *
- * Example (router-independent — see `useRouterAdapter`, the same seam
- * `useResourceUrlState` uses; wrap the app in `RouterAdapterProvider` once):
+ * Example (router-independent — picks navigate through `useRouteNavigate`,
+ * the `RouterAdapter` seam `useResourceUrlState` also uses; wrap the app in
+ * `RouterAdapterProvider` once):
  *
  * ```tsx
  * 'use client';
- * import { useRouterAdapter, useCommandPalette, useApp } from '@burojs/react';
+ * import { useCommandPalette } from '@burojs/react';
  * import {
  *   CommandPalette,
  *   CommandPaletteRecentGroup,
@@ -1094,18 +1141,15 @@ interface CommandPaletteRecentGroupProps {
  * } from '@burojs/ui-shadcn';
  *
  * function Shell() {
- *   const router = useRouterAdapter();
  *   const { open, setOpen } = useCommandPalette();
  *   return (
  *     <CommandPalette open={open} onOpenChange={setOpen}>
  *       <CommandPaletteRecentGroup
- *         navigate={(href) => router.push(href)}
  *         onSelect={() => setOpen(false)}
  *         refreshKey={open}
  *       />
  *       <CommandSeparator />
  *       <CommandPaletteNavigationGroups
- *         navigate={(href) => router.push(href)}
  *         onSelect={() => setOpen(false)}
  *       />
  *     </CommandPalette>
@@ -1113,7 +1157,7 @@ interface CommandPaletteRecentGroupProps {
  * }
  * ```
  */
-declare function CommandPaletteRecentGroup({ userId, navigate, onSelect, getTestId, heading, recordHref, refreshKey, withSeparator }: CommandPaletteRecentGroupProps): React.ReactElement | null;
+declare function CommandPaletteRecentGroup({ onSelect, getTestId, heading, refreshKey, withSeparator }: CommandPaletteRecentGroupProps): React.ReactElement | null;
 //#endregion
 //#region src/layout/command-palette-records-group.d.ts
 /**
@@ -1162,14 +1206,7 @@ interface CommandPaletteRecordsGroupProps {
    */
   debounceMs?: number;
   /**
-   * Called to navigate to the picked record's URL. Wire this to your
-   * app router (`router.push` for Next App Router, `navigate(to)` for
-   * react-router, etc.). Optional — when omitted the component falls
-   * back to `window.location.assign(href)` (full reload).
-   */
-  navigate?: (href: string) => void;
-  /**
-   * Called BEFORE `navigate` fires. Adopters typically wire this to
+   * Called BEFORE the navigation. Adopters typically wire this to
    * `setOpen(false)` to close the palette during the route change.
    */
   onSelect?: () => void;
@@ -1207,7 +1244,7 @@ interface CommandPaletteRecordsGroupProps {
  * - Each resource hit is prefixed with the resource's label so an
  *   ambiguous query (matching multiple resources) stays disambiguated.
  * - On pick: calls `onSelect` (typical: close the palette) THEN
- *   `navigate(href)`.
+ *   navigates to the record.
  *
  * Cancellation:
  *
@@ -1224,12 +1261,13 @@ interface CommandPaletteRecordsGroupProps {
  * that calls `useList` exactly once per render. The sub-component count
  * is stable, so no conditional/loop hook is created.
  *
- * Example (router-independent — see `useRouterAdapter`, the same seam
- * `useResourceUrlState` uses; wrap the app in `RouterAdapterProvider` once):
+ * Example (router-independent — picks navigate through `useRouteNavigate`,
+ * the `RouterAdapter` seam `useResourceUrlState` also uses; wrap the app in
+ * `RouterAdapterProvider` once):
  *
  * ```tsx
  * 'use client';
- * import { useRouterAdapter, useCommandPalette } from '@burojs/react';
+ * import { useCommandPalette } from '@burojs/react';
  * import {
  *   CommandPalette,
  *   CommandPaletteRecordsGroup,
@@ -1237,17 +1275,14 @@ interface CommandPaletteRecordsGroupProps {
  * } from '@burojs/ui-shadcn';
  *
  * function Shell() {
- *   const router = useRouterAdapter();
  *   const { open, setOpen } = useCommandPalette();
  *   return (
  *     <CommandPalette open={open} onOpenChange={setOpen}>
  *       <CommandPaletteRecordsGroup
  *         enabled={open}
- *         navigate={(href) => router.push(href)}
  *         onSelect={() => setOpen(false)}
  *       />
  *       <CommandPaletteNavigationGroups
- *         navigate={(href) => router.push(href)}
  *         onSelect={() => setOpen(false)}
  *       />
  *     </CommandPalette>
@@ -1255,7 +1290,7 @@ interface CommandPaletteRecordsGroupProps {
  * }
  * ```
  */
-declare function CommandPaletteRecordsGroup({ enabled, pageSize, minQueryLength, debounceMs, navigate, onSelect, getTestId, heading, recordHref }: CommandPaletteRecordsGroupProps): React.ReactElement | null;
+declare function CommandPaletteRecordsGroup({ enabled, pageSize, minQueryLength, debounceMs, onSelect, getTestId, heading, recordHref }: CommandPaletteRecordsGroupProps): React.ReactElement | null;
 //#endregion
 //#region src/layout/command-palette-actions-group.d.ts
 /**
@@ -1279,8 +1314,8 @@ type CommandPaletteActionsTestIdRole = 'action';
  * about WHICH actions appear: it also reads `useAppActions()` and renders
  * those alongside the prop list — see the component's own docblock for the
  * merge order. Each action has a single activation path: either `href`
- * (delegates to `navigate(href)`) OR `onRun` (custom handler). When both
- * are provided `href` wins.
+ * (navigates through `useRouteNavigate`) OR `onRun` (custom handler). When
+ * both are provided `href` wins.
  */
 interface ActionItem {
   /** Stable id used for the cmdk `value` and the optional `getTestId` callback. */
@@ -1304,11 +1339,12 @@ interface ActionItem {
    */
   onRun?: () => void | Promise<void>;
   /**
-   * Optional href shortcut: when set, the component runs
-   * `navigate(href)` (passed through the same `onSelect` → close →
-   * navigate flow used elsewhere in the palette) and `onRun` is not
-   * called. Use this for actions that are really just navigation
-   * shortcuts (e.g. `"Create new <resource>"`).
+   * Optional href shortcut: when set, the component navigates to it
+   * through `useRouteNavigate` (the same navigate → `onSelect` → close
+   * flow used elsewhere in the palette) and `onRun` is not called. An
+   * external href (`https:`, `mailto:`) opens in a new window instead.
+   * Use this for actions that are really just navigation shortcuts
+   * (e.g. `"Create new <resource>"`).
    */
   href?: string;
   /**
@@ -1356,14 +1392,7 @@ interface CommandPaletteActionsGroupProps {
    */
   actions?: ActionItem[];
   /**
-   * Called to navigate when an action's `href` is set. Wire this to
-   * your app router (`router.push` for Next App Router, etc.). When
-   * omitted the component falls back to `window.location.assign(href)`
-   * (full reload). SPAs should always supply `navigate`.
-   */
-  navigate?: (href: string) => void;
-  /**
-   * Called AFTER the action's handler resolves (or `navigate(href)`
+   * Called AFTER the action's handler resolves (or the navigation
    * fires). Adopters typically wire this to `setOpen(false)` so the
    * palette closes once the user has picked an action.
    */
@@ -1408,8 +1437,8 @@ interface CommandPaletteActionsGroupProps {
  * - Errors thrown / rejected from `onRun` are caught + logged via
  *   `console.error` and the palette still closes — the user is never
  *   stuck on an overlay after a misbehaving handler.
- * - Actions with `href` set bypass `onRun` and delegate to
- *   `navigate(href)` (or `window.location.assign` as a fallback).
+ * - Actions with `href` set bypass `onRun` and navigate through
+ *   `useRouteNavigate`; an external href opens in a new window.
  * - A registry entry the rule engine allowed-but-disabled (`disabled: true`)
  *   stays keyboard-reachable and dimmed (`opacity-60`), and selecting it
  *   shows its `disabledReason` via `toast` instead of running the action —
@@ -1436,12 +1465,11 @@ interface CommandPaletteActionsGroupProps {
  *       keywords: 'logout sign out',
  *     },
  *   ]}
- *   navigate={(href) => router.push(href)}
  *   onSelect={() => setOpen(false)}
  * />
  * ```
  */
-declare function CommandPaletteActionsGroup({ actions, navigate, onSelect, getTestId, heading }: CommandPaletteActionsGroupProps): React.ReactElement | null;
+declare function CommandPaletteActionsGroup({ actions, onSelect, getTestId, heading }: CommandPaletteActionsGroupProps): React.ReactElement | null;
 //#endregion
 //#region src/layout/command-palette-create-group.d.ts
 /**
@@ -1458,19 +1486,12 @@ type CommandPaletteCreateTestIdRole = 'create';
 interface CommandPaletteCreateGroupProps {
   /**
    * Override which resources expose a Create entry. Default: every
-   * non-embedded resource that passes its `visible(ctx)` predicate.
+   * resource with a list page that passes its `visible(ctx)` predicate.
    * Adopters who want to hide a specific resource's Create action
    * (e.g. read-only views, demo-only resources) supply a predicate
    * that returns `false` for that resource.
    */
   resourceFilter?: (def: ResourceDef) => boolean;
-  /**
-   * Called to navigate to `/${resource}/create`. Wire this to your
-   * app router (`router.push` for Next App Router, etc.). When omitted
-   * the component falls back to `window.location.assign(href)` (full
-   * reload). SPAs should always supply `navigate`.
-   */
-  navigate?: (href: string) => void;
   /**
    * Called AFTER the navigation fires. Adopters typically wire this
    * to `setOpen(false)` so the palette closes once the user has
@@ -1491,7 +1512,7 @@ interface CommandPaletteCreateGroupProps {
   /**
    * Override the path generator. By default each item navigates to
    * `/<resource>/create`. Adopters with custom create routes
-   * (e.g. wizards, modals) override per-resource.
+   * (e.g. a dedicated flow, a modal) override per-resource.
    */
   createHref?: (def: ResourceDef) => string;
   /**
@@ -1504,14 +1525,12 @@ interface CommandPaletteCreateGroupProps {
 /**
  * Render the per-resource quick-action group inside a command
  * palette: one `"Create new <resource>"` item per registered
- * (non-embedded, visible) resource.
+ * visible resource with a list page.
  *
  * Filters applied (in order):
  *
- * 1. `parent.embedded === true` resources are excluded — they don't
- *    have a standalone create route in the framework's routing
- *    convention; their create flow lives inside the parent's show
- *    page tab.
+ * 1. Resources with no list page (`views.list.page: false`) are
+ *    excluded — they are reached through a parent's placement.
  * 2. `evaluateVisible(def.visible, visibilityCtx)` must return true.
  *    Same predicate the sidebar + navigation group use, fail-closed
  *    on throwing predicates. Hidden in sidebar → hidden here.
@@ -1525,13 +1544,12 @@ interface CommandPaletteCreateGroupProps {
  *
  * ```tsx
  * <CommandPaletteCreateGroup
- *   navigate={(href) => router.push(href)}
  *   onSelect={() => setOpen(false)}
  *   getTestId={(role, name) => `command-palette-${role}:${name}`}
  * />
  * ```
  */
-declare function CommandPaletteCreateGroup({ resourceFilter, navigate, onSelect, getTestId, heading, createHref, prefix }: CommandPaletteCreateGroupProps): React.ReactElement | null;
+declare function CommandPaletteCreateGroup({ resourceFilter, onSelect, getTestId, heading, createHref, prefix }: CommandPaletteCreateGroupProps): React.ReactElement | null;
 //#endregion
 //#region src/layout/link-component.d.ts
 /**
@@ -1551,67 +1569,31 @@ type LinkComponentProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'>
   children?: ReactNode;
 };
 type LinkComponent = ComponentType<LinkComponentProps>;
-/**
- * Imperative client-side navigation. Mirrors the `<Link>` mechanism for the
- * cases a component must navigate from an event handler (e.g. a whole-row click
- * on a list, #4) rather than render an anchor. The default performs a full-page
- * `window.location.assign`; adopters install their router's push
- * (`next/router`'s `router.push`, react-router's `navigate`) via
- * `<LinkComponentProvider navigate={...}>` so it stays client-side.
- */
-type NavigateFn = (href: string) => void;
-/**
- * Read the imperative navigate function. Use for programmatic navigation from an
- * event handler; prefer `useLinkComponent()` (a real anchor) whenever the target
- * can be rendered as a link, since anchors give Cmd/Ctrl-click, middle-click and
- * right-click "open in new tab" for free.
- */
-declare function useNavigate(): NavigateFn;
-/**
- * Read the app's current pathname. Supplied by `LinkComponentProvider`
- * (`currentPath` prop, e.g. Next's `usePathname()` or react-router's
- * `useLocation().pathname`). Defaults to '' when no provider is present
- * (SSR-safe). This is the read side of the router seam — `useMatch` uses it
- * to resolve the active route via `matchPath`.
- */
-declare function useCurrentPath(): string;
 interface LinkComponentProviderProps {
   /**
-   * The router-aware Link component to use throughout
-   * `@burojs/ui-shadcn` for internal navigation. Pass `Link` from
-   * `next/link` for Next.js App Router; wrap your router's link
-   * primitive once for react-router / TanStack Router.
+   * The router-aware Link component to use throughout `@burojs/ui-shadcn` for
+   * internal navigation. Pass `Link` from `next/link` for Next.js App Router;
+   * wrap your router's link primitive once for react-router / TanStack Router.
    */
   linkComponent: LinkComponent;
-  /**
-   * Optional imperative navigate (client-side) for handler-driven navigation
-   * such as whole-row clicks. Defaults to a full-page `window.location.assign`.
-   */
-  navigate?: NavigateFn;
-  /**
-   * The app's current pathname; feed `usePathname()` (Next) or
-   * `useLocation().pathname` (react-router).
-   */
-  currentPath?: string;
   children: ReactNode;
 }
 /**
- * Install a router-aware `LinkComponent` for every framework component
- * that renders an internal navigation link (Sidebar entries, action
- * links, relation cells, list-empty Create CTA, etc.). Without this
- * provider the framework falls back to a raw `<a>` — works correctly
- * but causes a full document reload on every click, which defeats the
- * SPA experience a client-side router (Next.js, react-router) is meant
- * to provide.
+ * Install a router-aware `LinkComponent` for every framework component that
+ * renders an internal navigation link (sidebar entries, action links, relation
+ * cells, the list-empty Create CTA, …). Without it the framework falls back to
+ * a raw `<a>` — correct, but a full document reload on every click.
  *
- * Wire-up:
+ * This is a link component and nothing else: the location and imperative
+ * navigation are the `RouterAdapter`'s (`RouterAdapterProvider` and
+ * `useRouteNavigate` from `@burojs/react`), the one router seam.
  *
  *   import Link from 'next/link';
  *   <LinkComponentProvider linkComponent={Link}>
  *     <App />
  *   </LinkComponentProvider>
  */
-declare function LinkComponentProvider({ linkComponent, navigate, currentPath, children }: LinkComponentProviderProps): ReactElement;
+declare function LinkComponentProvider({ linkComponent, children }: LinkComponentProviderProps): ReactElement;
 /**
  * Read the current `LinkComponent`. Call this from any framework
  * component that needs to render an internal-navigation link, then
@@ -1629,52 +1611,87 @@ declare function useLinkComponent(): LinkComponent;
 /**
  * The app-scoped visibility predicate passed to the pure core resolvers so
  * that group-index → first-visible-child resolution and (later) chrome item
- * lists honor `visible(ctx)`. Resources and groups consult `evaluateVisible`
- * against the current visibility context; custom pages have no predicate and
- * are always visible.
+ * lists honor `visible(ctx)`. Resources, groups and custom pages consult
+ * `evaluateVisible` against the current visibility context; a node without a
+ * predicate is visible. The custom-page route gates on it too (`<PageHost>`).
  */
 declare function useNavVisible(): (node: NavNode) => boolean;
 /** Canonical href for a resource / custom page / group. Nesting-independent. */
 declare function useHref(name: string, opts?: Omit<HrefOpts, 'isVisible'>): string;
-/** Resolve the active route from the current pathname, or null. */
+/**
+ * Resolve the active route from the router adapter's pathname, or null. The
+ * router adapter is the framework's only source of the location; without one
+ * there is no location, so there is no match.
+ */
 declare function useMatch(): RouteMatch | null;
 //#endregion
-//#region src/layout/navigation-guard.d.ts
+//#region src/layout/navigation-guard-dialog.d.ts
 /**
- * Arm/disarm the navigation guard from a component. Pass `true` while the
- * component holds unsaved changes (e.g. a dirty form). No-op when no
- * `NavigationGuardProvider` is mounted above.
+ * The unsaved-changes guard's "leave?" dialog. The guard itself — which clicks
+ * it holds, `beforeunload`, the back-button sentinel — is `@burojs/react`'s and
+ * mounted by `<BuroProvider>`; this component registers itself as the guard's
+ * dialog while mounted and answers the navigation the guard is holding.
+ * `<AppLayout>` renders one, so an app on the layout mounts nothing; an app
+ * without it renders this once inside `<BuroProvider>`. With no dialog
+ * registered the guard asks through `window.confirm`.
+ *
+ * A second mounted dialog stays closed: the guard hands a held navigation to
+ * the most recently registered dialog only, and back to the previous one when
+ * that one unmounts.
  */
-declare function useNavigationBlocker(active: boolean): void;
-declare function NavigationGuardProvider({ children }: {
-  children: ReactNode;
-}): React.ReactElement;
+declare function NavigationGuardDialog(): ReactElement;
 //#endregion
-//#region src/layout/nav-user.d.ts
-interface NavUserProps {
-  name: string;
-  email: string;
-  /** 1–2 char fallback shown in the avatar circle. */
-  avatarFallback: string;
-  /** Extra dropdown rows rendered above the logout item (theme/language/role, etc.). */
-  menu?: ReactNode;
-  onLogout: () => void;
-  logoutLabel?: string;
+//#region src/shell/refresh-button.d.ts
+interface RefreshButtonProps {
+  readonly className?: string;
 }
-declare function NavUser({ name, email, avatarFallback, menu, onLogout, logoutLabel }: NavUserProps): React.ReactElement;
+/** Ghost icon button that refetches the app's data; spins and disables while it runs. */
+declare function RefreshButton({ className }: RefreshButtonProps): ReactElement | null;
+//#endregion
+//#region src/shell/app-actions.d.ts
+/**
+ * The app-level action strip: every `defineAppAction` entry that belongs to no resource, already
+ * filtered by the rule engine (`useAppActions`). Only entries that resolve to a route render: a
+ * `link`, or a flow hosted on a page (`hostHref`). A `modal` entry needs a presentation host and is
+ * skipped. `disabledReason` keeps the action visible but inert, with the reason as its tooltip.
+ */
+declare function AppActions(): ReactElement | null;
+//#endregion
+//#region src/shell/help-button.d.ts
+type HelpButtonProps = {
+  readonly className?: string;
+} & ({
+  readonly href: string;
+  readonly onClick?: never;
+} | {
+  readonly onClick: () => void;
+  readonly href?: never;
+});
+/** Ghost icon button that opens help: a link when given `href`, a button when given `onClick`. */
+declare function HelpButton({ href, onClick, className }: HelpButtonProps): ReactElement;
 //#endregion
 //#region src/layout/app-header.d.ts
+/** Every slot follows {@link Slot}: omit for the default, `false` for nothing, an element to replace. */
 interface AppHeaderProps {
-  breadcrumbs?: ReactNode;
-  search?: ReactNode;
-  actions?: ReactNode;
+  /** The breadcrumb trail. Default `<HeaderBreadcrumbs />`, the current route's trail. */
+  breadcrumbs?: Slot;
+  /**
+   * The search chip. Default `<CommandPaletteTrigger />`, which renders only
+   * when the `ShellProvider` has an `openPalette`.
+   */
+  search?: Slot;
+  /**
+   * The right-hand controls. Default `<AppActions />` and `<RefreshButton />`;
+   * each renders nothing when it has nothing to show.
+   */
+  actions?: Slot;
   className?: string;
 }
 declare function AppHeader({ breadcrumbs, search, actions, className }: AppHeaderProps): React.ReactElement;
 //#endregion
 //#region src/layout/document-title.d.ts
 /**
- * Register the desired `document.title` for the current page. Under a
+ * Register the desired `document.title` for the current page (suffixed with ` · <brand name>` under a `ShellProvider` brand). Under a
  * `DocumentTitleProvider` the title is applied AND DEFENDED against Next's
  * metadata writes (Next re-applies the root `metadata.title` to `<title>` on
  * soft navigations — same-URL clicks, `?query` changes, post-hydration ticks —
@@ -1714,62 +1731,19 @@ declare function DocumentTitleProvider({ routeKey, children }: {
 //#region src/notification/toaster.d.ts
 interface ToasterProps extends ToasterProps$1 {}
 /**
- * Shadcn-canonical Sonner setup. Bound to design tokens via
- * `toastOptions.classNames` so toasts inherit the app's light/dark
- * theme through the same CSS-variable cascade as the rest of the UI.
+ * Shadcn-canonical Sonner setup, and — inside a `<BuroProvider>` — the app's
+ * notification sink: the dispatcher's default `notify` (every handler's
+ * `notify`, and a thrown handler's error) is delivered here. Outside a
+ * provider it registers nothing and still renders anything sent with `toast()`.
  *
- * Differences from the old default:
- *   - Dropped `richColors` (it set Sonner's own success/error palette,
- *     overriding the theme tokens we now wire in).
- *   - `theme` is reactive via `useTheme()` (packages/ui-shadcn/src/layout/use-theme.ts),
- *     so any writer flipping the app theme — the command palette, the user
- *     submenu — flips the toast theme without a remount.
- *   - Toast surface, border, shadow, and description text are pinned
- *     to `bg-background` / `text-foreground` / `border-border` / etc.,
- *     matching Card and AlertDialog primitives.
+ * Bound to design tokens via `toastOptions.classNames`, so toasts inherit the
+ * app's light/dark theme through the same CSS-variable cascade as the rest of
+ * the UI; `theme` is reactive via `useTheme()`. The error catalogue follows the
+ * ACTIVE i18n locale, read per toast so a language switch is honoured; with no
+ * i18n provider it falls back to the locale `<LanguageSwitch>` persisted.
  */
 declare function Toaster(props: ToasterProps): React.ReactElement;
 //#endregion
-//#region src/notification/notification-provider.d.ts
-interface NotificationSink {
-  open(args: {
-    readonly type: 'success' | 'error' | 'progress';
-    readonly message: string;
-    readonly description?: string;
-  }): void;
-  close(key: string): void;
-}
-/**
- * A legacy query adapter can build its default query-error notification outside
- * our i18n bundle: in a Russian-primary app the user
- * saw «Error (status code: undefined)» / «Failed to fetch», plus it duplicated
- * the inline error state a list already renders. We can't localize a string we
- * don't own, so `toFriendlyError` recognises it and substitutes plain language.
- * The SAME helper backs the list's inline panel — see friendly-error.ts for why
- * that matters.
- */
-interface NotificationProviderOptions {
-  /**
-   * How to find the ACTIVE locale when an error toast needs its catalogue.
-   * Defaults to the locale persisted by `<LanguageSwitch>` under
-   * {@link DEFAULT_LANGUAGE_STORAGE_KEY}.
-   *
-   * The escape hatch exists because the default is only right for an app that
-   * left `storageKey` alone: `<LanguageSwitch storageKey="acme:lang">` writes
-   * somewhere this factory does not look, and the toast would silently take the
-   * fallback catalogue forever. Such an app passes
-   * `{ resolveLocale: () => loadLocale('acme:lang') }` — or reads its own i18n
-   * facade directly, which is strictly better still.
-   *
-   * ⚠️ It is a FUNCTION, not a value, and that is load-bearing: both examples
-   * build this sink once (`React.useMemo(…, [])`) and it has no React context
-   * to subscribe to, so a locale captured at construction would freeze at
-   * whatever was active on the first render. Called per toast instead.
-   */
-  readonly resolveLocale?: () => string | undefined;
-}
-declare function createNotificationProvider(options?: NotificationProviderOptions): NotificationSink;
-//#endregion
 //#region src/auth/login-form.d.ts
 declare const schema: z.ZodObject<{
   email: z.ZodString;
@@ -1793,7 +1767,10 @@ declare function LoginForm({ onSubmit, title, description, className }: LoginFor
 //#region src/auth/auth-page.d.ts
 interface AuthPageProps {
   children: ReactNode;
-  /** Optional brand mark / logo above the auth card. */
+  /**
+   * The brand above the auth card. Omit it for `<BrandMark />` (the `ShellProvider` brand, if
+   * any); pass `false` for none; pass an element to replace it.
+   */
   brand?: ReactNode;
   /** Optional footer text under the auth card (e.g. legal). */
   footer?: ReactNode;
@@ -1830,13 +1807,28 @@ declare const shadcnFieldImplementations: Readonly<{
   'default:date-time': FieldImplementation<unknown, Readonly<Record<string, unknown>>>;
   enum: FieldImplementation<unknown, Readonly<Record<string, unknown>>>;
   json: FieldImplementation<unknown, Readonly<Record<string, unknown>>>;
-  relation: FieldImplementation<unknown, Readonly<Record<string, unknown>>>;
+  relation: Readonly<{
+    Input?: import("react").ComponentType<ScalarInputProps<unknown, Readonly<Record<string, unknown>>>> | undefined;
+    Display?: import("react").ComponentType<ScalarDisplayProps<unknown, Readonly<Record<string, unknown>>>> | undefined;
+    CollectionInput?: import("react").ComponentType<CollectionInputProps<unknown, Readonly<Record<string, unknown>>>> | undefined;
+    CollectionDisplay?: import("react").ComponentType<CollectionDisplayProps<unknown, Readonly<Record<string, unknown>>>> | undefined;
+    layout?: FieldImplementationLayout;
+    meta: import("@burojs/core").StandardSchemaV1<unknown, Readonly<Record<string, unknown>>>;
+  }>;
   richText: FieldImplementation<unknown, Readonly<Record<string, unknown>>>;
   'rich-text': FieldImplementation<unknown, Readonly<Record<string, unknown>>>;
   'default:rich-text': FieldImplementation<unknown, Readonly<Record<string, unknown>>>;
   file: FieldImplementation<unknown, Readonly<Record<string, unknown>>>;
 }>;
 //#endregion
+//#region src/blocks/builtins.d.ts
+/**
+ * The built-in block views (`buro:*`), keyed by block id. The renderer composes them first and
+ * the app's `blockImplementations` over them: an app entry with a built-in id replaces that view
+ * (with a development notice); a built-in cannot be dropped.
+ */
+declare const shadcnBlockImplementations: BlockImplementationCatalog;
+//#endregion
 //#region src/fields/registry.d.ts
 interface FieldRendererProps {
   value: unknown;
@@ -1850,7 +1842,7 @@ interface FieldRendererProps {
   };
   options?: Array<{
     value: string;
-    label: LocalizedMessage;
+    label: string;
     icon?: string;
   }>;
   /**
@@ -1878,6 +1870,15 @@ interface FieldRendererProps {
 }
 interface FieldInputProps {
   name: string;
+  /** A relation select's create seeds (P6-31): the registry's `candidates` literals. */
+  relationSeeds?: Readonly<Record<string, unknown>>;
+  /** A relation select's extra filters from the form's `filter` function (P7 3.4). */
+  fixedFilters?: readonly FixedFilterInput[];
+  /**
+   * The field owner's source states, projected by what the user may view: what a relation's
+   * `candidates` refs are read from (P7 3.4).
+   */
+  metaSources?: ScreenSources;
   id?: string;
   value: unknown;
   /** True when this renderer is reached through a collection implementation. */
@@ -1886,7 +1887,7 @@ interface FieldInputProps {
   testid?: string;
   options?: Array<{
     value: string;
-    label: LocalizedMessage;
+    label: string;
     icon?: string;
   }>;
   placeholder?: string;
@@ -1900,7 +1901,7 @@ interface FieldInputProps {
   pattern?: string;
   /**
    * When true, renders `aria-invalid="true"` on the underlying input
-   * control. Forwarded by `<ResourceForm>` for fields that have a
+   * control. Forwarded by `<RecordScreen>` for fields that have a
    * non-null validation error AND have been touched (blurred or
    * post-submit). Renderers should pass this through to their root
    * input element so screen-readers can announce the invalid state.
@@ -1919,18 +1920,18 @@ interface FieldInputProps {
    * `aria-errormessage` on their root input element so screen-readers
    * with WAI-ARIA 1.2 support associate the error specifically.
    * `aria-invalid="true"` must also be set for `aria-errormessage` to
-   * be honored — `<ResourceForm>` already wires both together.
+   * be honored — `<RecordScreen>` already wires both together.
    */
   ariaErrorMessage?: string;
   /**
    * Field metadata, mirroring `FieldRendererProps.field`. Forwarded by
-   * `<ResourceForm>` so renderers that depend on per-field meta (e.g.
+   * `<RecordScreen>` so renderers that depend on per-field meta (e.g.
    * the relation picker reading `meta.to` for the target resource) can
    * read it. Renderers that don't care simply ignore the prop.
    *
    * The `ui` block carries the field-type-specific renderer config
    * (e.g. `<FileInput>` reads `ui.accept` / `ui.maxSize` /
-   * `ui.fileStorage`). Forwarded by `<ResourceForm>` from the field
+   * `ui.fileStorage`). Forwarded by `<RecordScreen>` from the field
    * definition's `def.ui` block.
    *
    * Optional for backward compatibility — every existing renderer was
@@ -1975,8 +1976,8 @@ declare function DateDisplay({ value }: FieldRendererProps): React$1.ReactElemen
 declare function DateInput({ name, id, value, onChange, testid, disabled, required, ariaInvalid, ariaDescribedBy, ariaErrorMessage }: FieldInputProps): React$1.ReactElement;
 //#endregion
 //#region src/fields/enum.d.ts
-declare function EnumDisplay({ value, options, field }: FieldRendererProps): React$1.ReactElement;
-declare function EnumInput({ name, id, value, onChange, testid, options, field, placeholder, disabled, required, ariaInvalid, ariaDescribedBy, ariaErrorMessage }: FieldInputProps): React$1.ReactElement;
+declare function EnumDisplay({ value, options, field, resource }: FieldRendererProps): React$1.ReactElement;
+declare function EnumInput({ name, id, value, onChange, testid, options, field, placeholder, disabled, required, ariaInvalid, ariaDescribedBy, ariaErrorMessage, resource }: FieldInputProps): React$1.ReactElement;
 //#endregion
 //#region src/fields/textarea.d.ts
 declare function TextareaDisplay({ value }: FieldRendererProps): React$1.ReactElement;
@@ -2042,6 +2043,25 @@ declare function RelationField({ to, value }: {
   /** FK value to resolve, or null/undefined/'' when empty. */
   value: unknown;
 }): React$1.ReactElement;
+/**
+ * A to-many relation (`f.relationMany`): each key rendered as {@link RelationDisplay} renders
+ * one — eager keys share the aggregator's batched read, lazy keys read nothing.
+ */
+declare function RelationManyDisplay({ value, field }: FieldRendererProps): React$1.ReactElement;
+//#endregion
+//#region src/fields/candidates-gate.d.ts
+/** A select that must not read its target now (P7 3.4): why, and what it tells the user. */
+type CandidatesGate = {
+  readonly kind: 'pending';
+} | {
+  readonly kind: 'empty';
+  readonly message: string;
+  readonly testId: string;
+} | {
+  readonly kind: 'forbidden';
+  readonly message: string;
+  readonly testId: string;
+};
 //#endregion
 //#region src/fields/relation-picker.d.ts
 /**
@@ -2074,8 +2094,13 @@ interface RelationPickerProps {
   to: string;
   /** Currently-selected FK value, or null/undefined when empty. */
   value: string | number | null | undefined;
-  /** Called with the new selected id, or null when cleared. */
+  /** Called with the new selected id (or `by` value), or null when cleared. */
   onChange: (next: string | number | null) => void;
+  /**
+   * The target field the value holds (`meta.by`, spec 4.2): options write `row[by]` and the
+   * selected value is resolved by it. Absent: the target's id field.
+   */
+  by?: string;
   /**
    * Field whose value is matched against the search text. Defaults to
    * the target's `displayField` (which is what the trigger label
@@ -2106,6 +2131,27 @@ interface RelationPickerProps {
    * user, and add `label` to render it as an undeletable badge instead.
    */
   fixedFilters?: readonly FixedFilterInput[];
+  /**
+   * The trusted `defaults` of a create opened from this select (P6-31): the registry field's
+   * static `eq` literals, handed down by the form controller. Never read from `fixedFilters` or
+   * `field.meta`.
+   */
+  createSeeds?: Readonly<Record<string, unknown>>;
+  /**
+   * What the field's `candidates` say about reading the target right now (P7 3.4): `pending`
+   * draws a disabled trigger, `empty` a popover that says what to choose first, `forbidden` a
+   * disabled trigger and why. While set, nothing is read for the options. Absent: read normally.
+   */
+  candidatesGate?: CandidatesGate;
+  /**
+   * Whether a loaded row fits the resolved candidate filters (already in `fixedFilters`):
+   * `false` makes the field say the chosen row "does not match the current filter" (P7 3.4).
+   */
+  rowFits?: (row: Record<string, unknown>) => boolean | undefined;
+  /** The form field holding the key (the "view" and "+ create" test ids); defaults to `name`. */
+  fieldName?: string;
+  /** The field's `ui.open` (P7 3.6): what the "view" button opens, or no button for `none`. */
+  open?: RelationOpen;
   disabled?: boolean;
   required?: boolean;
   className?: string;
@@ -2116,7 +2162,7 @@ interface RelationPickerProps {
   /** Forwarded to the trigger button as `aria-errormessage` (WAI-ARIA 1.2). */
   ariaErrorMessage?: string;
 }
-declare function RelationPicker({ to, value, onChange, searchField, pageSize, clearable, placeholder, name, id, testid, fixedFilters, disabled, required, className, ariaInvalid, ariaDescribedBy, ariaErrorMessage }: RelationPickerProps): React$1.ReactElement;
+declare function RelationPicker({ to, value, onChange, by, searchField, pageSize, clearable, placeholder, name, id, testid, fixedFilters, createSeeds, candidatesGate, rowFits, fieldName, open: openMode, disabled, required, className, ariaInvalid, ariaDescribedBy, ariaErrorMessage }: RelationPickerProps): React$1.ReactElement;
 /**
  * Form-field adapter wrapping `<RelationPicker>` for use as a default
  * Input renderer in the field registry. Reads `field.meta.to` for the
@@ -2126,6 +2172,20 @@ declare function RelationPicker({ to, value, onChange, searchField, pageSize, cl
  */
 declare function RelationPickerInput(props: FieldInputProps): React$1.ReactElement;
 //#endregion
+//#region src/fields/relation-create.d.ts
+/** What the picker and its dialog share: one pending create per select (P6-34). */
+interface SelectCreate {
+  readonly pending: boolean;
+  /**
+   * The hand-back read is forbidden: its filter names a field P5 hides from the user (the same
+   * rule that stops the picker's own option read), or the access map is not ready. A blocked
+   * select offers no "+ Create" and starts none, so no predicate on a hidden field is ever sent.
+   */
+  readonly blocked: boolean;
+  /** Runs `open` unless a create of this select is already pending or the select is gone. */
+  start(open: () => Promise<QuickSettledRow>): void;
+}
+//#endregion
 //#region src/fields/relation-picker-dialog.d.ts
 /**
  * Advanced-search modal for the relation picker (#11 / #9). The inline popover
@@ -2176,11 +2236,34 @@ interface RelationPickerDialogProps {
    * renders it as an undeletable badge.
    */
   fixedFilters?: readonly FixedFilterInput[];
-  /** Create href for the "+ Create" shortcut. Defaults to the target basePath + /create. */
-  createHref?: string;
+  /**
+   * The select's one pending create (P6-34), shared with its popover. With it the footer offers
+   * "+ Create" (the target's `quick.create`, handed back through the select's own query); without
+   * it the dialog offers none. The dialog is not a dismiss scope and holds no form: the sheet a
+   * create opens stacks above it.
+   */
+  create?: SelectCreate;
+  /** The trusted `defaults` of that create: the registry field's static `eq` literals (P6-31). */
+  createSeeds?: Readonly<Record<string, unknown>>;
+  /** The form field holding the key (the create button's test id). */
+  fieldName?: string;
+  /** Runs before a create opens: the select returns focus to its trigger. */
+  onBeforeCreate?: () => void;
   pageSize?: number;
+  /**
+   * A to-many select's choice (P7 3.5): a click toggles the row in `selected` through `onToggle`
+   * and the dialog stays open until the user is done. Without it, a click picks one row and closes.
+   */
+  multiple?: boolean;
+  /** The keys already chosen (`multiple` only): their rows are marked. */
+  selected?: readonly (string | number)[];
+  onToggle?: (value: string | number) => void;
 }
-declare function RelationPickerDialog({ to, open, onOpenChange, onSelect, onSelectRow, searchField, valueField, fixedFilters, createHref, pageSize }: RelationPickerDialogProps): React$1.ReactElement;
+declare function RelationPickerDialog({ to, open, onOpenChange, onSelect, onSelectRow, searchField, valueField, fixedFilters, create, createSeeds, fieldName, onBeforeCreate, pageSize, multiple, selected, onToggle }: RelationPickerDialogProps): React$1.ReactElement;
+//#endregion
+//#region src/fields/lazy-relation-picker-dialog.d.ts
+/** The "Advanced search" dialog, loaded on the first open: nothing is drawn until it arrives. */
+declare function LazyRelationPickerDialog(props: ComponentProps<typeof RelationPickerDialog>): ReactElement;
 //#endregion
 //#region src/fields/use-dialog-filter-state.d.ts
 /** The portable erased AST — the only shape this module deals in. */
@@ -2222,6 +2305,10 @@ interface DialogFilterState {
   readonly fixed: readonly ResolvedFixedFilter[];
   /** The single expression to hand the data provider. */
   readonly filter: ErasedExpression | undefined;
+  /** Whether the target has a search for this user (no field left means no search box). */
+  readonly searchEnabled: boolean;
+  /** The read must not be sent: undecided access, or a filter naming a field the user may not view. */
+  readonly blocked: boolean;
   readonly reset: () => void;
 }
 /**
@@ -2322,6 +2409,12 @@ interface ResolvedFieldDisplayProps {
   readonly testId?: string;
   readonly fallback: ReactNode;
   readonly presentation?: FieldPresentation;
+  /**
+   * The owner's own source states, by name (P7 3.2): a form controller's projected `record` and
+   * `values`, a flow's `with` and `args`. They replace the sources built from `record` and
+   * `form`, so a field P5 withholds stays pending in a `meta` ref as it does everywhere else.
+   */
+  readonly metaSources?: ScreenSources;
 }
 interface ResolvedFieldInputProps extends Omit<ResolvedFieldDisplayProps, 'fallback'> {
   readonly inputId?: string;
@@ -2340,6 +2433,18 @@ interface ResolvedFieldInputProps extends Omit<ResolvedFieldDisplayProps, 'fallb
   readonly touched?: boolean;
   /** Optional canonical issues; localized errorMessage remains the fallback. */
   readonly issues?: ValidationIssues;
+  /**
+   * A relation select's create seeds (P6-31), from the form controller's binding. A separate
+   * channel from `field.meta`: the seeds' provenance is the code registry, and `meta` can be
+   * written by a layer.
+   */
+  readonly relationSeeds?: Readonly<Record<string, unknown>>;
+  /**
+   * A relation select's extra filters from the form's `filter` function (P7 3.4): code, handed
+   * down by the form controller on its own channel, applied on top of the field's `candidates`.
+   * Never read from `field.meta`, which a layer can write.
+   */
+  readonly fixedFilters?: readonly FixedFilterInput[];
   readonly fallback: ReactNode;
 }
 //#endregion
@@ -2349,15 +2454,12 @@ type FieldProps = Omit<ResolvedFieldInputProps, 'resource' | 'fallback'> & {
   readonly i18nPrefix?: string;
   readonly fallback?: ReactNode;
   /**
-   * A relation field's RESOLVED scope (design doc §5, `@burojs/react`'s
-   * `FieldBinding.fixedFilters`) — merged into the field's `meta.filters`
-   * before it reaches `ResolvedFieldInput`, the channel `RelationPickerInput`
-   * already reads off `field.meta.filters`
-   * (`relation-picker.tsx:478-487,526`). Any static `meta.filters` already
-   * on the field def is overridden, not merged, when this is supplied — the
-   * resolved per-render scope wins. `<DeclarativeForm>` never sets this
-   * explicitly: it spreads the whole `FieldBinding` (`{...binding}`), which
-   * already carries `fixedFilters` when the field declared a `filter` opt.
+   * A relation field's `filter` function RESOLVED against the form's values (design doc §5,
+   * `@burojs/react`'s `FieldBinding.fixedFilters`). It reaches the select on its own channel (a
+   * prop of the input, never `field.meta`, which a layer can write) and applies on top of the
+   * field's `candidates`. `<DeclarativeForm>` never sets this explicitly: it spreads the whole
+   * `FieldBinding` (`{...binding}`), which already carries `fixedFilters` when the field
+   * declared a `filter` function.
    *
    * `FixedFilterInput`, not the bare AST — matches `FieldBinding.fixedFilters`
    * (`@burojs/react`) and `RelationPickerProps`/`RelationPickerDialogProps`
@@ -2399,9 +2501,15 @@ type FieldDisplayProps = Omit<ResolvedFieldDisplayProps, 'resource' | 'fallback'
 declare function FieldDisplay({ resource, i18nPrefix, fallback, value, ...rest }: FieldDisplayProps): ReactElement;
 //#endregion
 //#region src/forms/declarative-form.d.ts
-/** A footer slot may need the controller's submit-gate to build its own submit control — see {@link DeclarativeFormSlots.footer}. */
+/**
+ * A footer slot may need the controller's submit-gate to build its own submit
+ * control — see {@link DeclarativeFormSlots.footer}.
+ */
 interface DeclarativeFormFooterCtx {
-  /** `form.canSubmit` already ANDed with the whole-form `disabled` lock — a footer never has to re-derive that combination itself. */
+  /**
+   * `form.canSubmit` already ANDed with the whole-form `disabled` lock — a
+   * footer never has to re-derive that combination itself.
+   */
   readonly canSubmit: boolean;
 }
 /**
@@ -2417,152 +2525,118 @@ interface DeclarativeFormSlots {
    * function form exists for the common case a plain node cannot serve: a
    * CUSTOM footer (e.g. Cancel + Submit side by side) that still needs the
    * framework's own disabled-while-invalid gate — `slots` is built by the
-   * CALLER before `useDeclarativeForm` has run, so a plain node has no way
+   * CALLER before the form controller has run, so a plain node has no way
    * to read `form.canSubmit`. Called once per render with `{ canSubmit }`
    * (already ANDed with the whole-form `disabled` lock) instead of forcing
    * every such caller to either reimplement the gate or stand up a second,
-   * parallel `useDeclarativeForm` instance just to read it (a real risk:
-   * two independent async-validation instances observably disagreeing for
-   * a tick — the first caller this was added for was `EntityDialog` in the
-   * since-deleted `apps/l2-web-ui`).
+   * parallel controller just to read it.
    */
   readonly footer?: ReactNode | ((ctx: DeclarativeFormFooterCtx) => ReactNode);
   readonly [slot: string]: ReactNode | ((ctx: DeclarativeFormFooterCtx) => ReactNode) | undefined;
 }
-interface DeclarativeFormProps {
+interface DeclarativeFormProps<F extends ResourceFieldMap = ResourceFieldMap> {
   /** The same field-def map shape `defineResource`'s `f` builder produces. */
-  readonly fields: ResourceFieldMap;
-  /** Controlled values. Presence (not truthiness) selects controlled mode — see `useDeclarativeForm`. */
+  readonly fields: F;
+  /**
+   * The form's tree (`(l) => [...]`, the same builder a resource's
+   * `views.<mode>.body` uses); absent, every field in one column, in
+   * declaration order. A field under a `when` that does not hold is inactive:
+   * it is not drawn and not submitted.
+   */
+  readonly body?: FormBody<F>;
+  /** The draft identity; `draft` without it is a development error. */
+  readonly formId?: string;
+  readonly draft?: DraftOption;
+  /** Controlled values: presence (not truthiness) selects controlled mode. */
   readonly value?: FormValues;
   /** Uncontrolled seed. Ignored once `value` is supplied. */
-  readonly defaultValue?: FormValues;
+  readonly defaults?: FormValues;
   readonly onChange?: (values: FormValues) => void;
-  /** Drives label i18n, the doc address, and the `<Field>` EntityRef — see `<Field>`'s own docblock. */
-  readonly i18nPrefix?: string;
   readonly schema?: StandardSchemaV1;
+  /** Cross-field validation; may return warnings as well as errors. */
+  readonly validate?: UseFormControllerFormOptions['validate'];
   /**
-   * Cross-field validation; may return warnings as well as errors. Typed off
-   * `UseDeclarativeFormOptions['validate']` (index access) rather than the
-   * controller's own `FormValidate` type, which `@burojs/react` keeps
-   * internal.
+   * Conditional checks for this form, as a plain list (a resource-less form has
+   * no `app.checkSource` entry); a confirmable warning asks through the
+   * mounted `<CheckConfirmDialog>`.
    */
-  readonly validate?: UseDeclarativeFormOptions['validate'];
+  readonly checks?: readonly Check[];
+  /** The check surface; default `'create'`. */
+  readonly surface?: CheckSurface;
+  /** Receives the payload: the active declared fields only. */
   readonly onSubmit?: (values: FormValues) => unknown | Promise<unknown>;
   /**
-   * Whole-form lock: every field renders disabled, OR-ed with that field's
-   * own resolved `disabled`. Distinct from a read-only VIEW, which renders
-   * display components instead of disabled inputs (`<DeclarativeDisplay>`,
-   * Task 7).
+   * Text slots and the doc address key as `resources.<i18nPrefix>.…`; the
+   * leaf ids are `<i18nPrefix>:field:<name>:hint` / `:info`. Default `'form'`.
    */
-  readonly disabled?: boolean;
-  /** Simple column-count switch. Defaults to a single column. */
-  readonly layout?: 'single' | 'two-column';
-  /**
-   * Class applied to the `<form>` element itself.
-   *
-   * Exists so a host can make the form a layout container rather than a
-   * plain block — the case that motivated it is a dialog taller than the
-   * viewport, where the form must become `flex flex-col` so its body can
-   * scroll between a fixed header and a fixed footer. Without it the host
-   * can only scroll the whole dialog, which drags the submit button out of
-   * reach.
-   */
-  readonly className?: string;
+  readonly i18nPrefix?: string;
   /**
-   * Class applied to the FIELDS container — the element holding the field
-   * grid, between the form-level issue summary and the footer.
-   *
-   * This is the scroll region for a form too tall to fit: pair it with
-   * `className` (`flex flex-col`) and give this `flex-1 overflow-y-auto
-   * min-h-0`. Kept separate from `className` because scrolling the whole
-   * form would scroll its footer away too, which is the bug rather than the
-   * fix.
+   * Whole-form lock: every field renders disabled, OR-ed with that field's
+   * own resolved `disabled`. Distinct from a read-only VIEW
+   * (`<DeclarativeDisplay>`), which renders displays instead of inputs.
    */
-  readonly bodyClassName?: string;
-  readonly slots?: DeclarativeFormSlots;
+  readonly disabled?: boolean;
   /**
    * Per-field render override — swap ONE field's node without abandoning
-   * the managed layout (label, unreserved message slot, submit gating all
-   * still apply around it). Receives the raw binding plus the default
-   * `<Field/>` node this renderer would have used, so an override can
-   * wrap/decorate rather than reimplement.
+   * the managed leaf (label, message slot, hint): receives the binding and
+   * the default input node, so an override can wrap rather than reimplement.
    */
   readonly renderField?: Record<string, (binding: FieldBinding, defaultNode: ReactNode) => ReactNode>;
+  readonly slots?: DeclarativeFormSlots;
+  /** The submit caption; defaults to the framework bundle's `actions.save` ("Save"). */
   readonly submitLabel?: string;
   /**
-   * Conditional checks (design doc `docs/superpowers/specs/2026-08-06-
-   * conditional-checks-design.md`) for this form. Declarative forms are
-   * resource-less, so — unlike `<ResourceForm>`, which resolves checks off
-   * the resource def via `app.checkSource` — these are a plain prop, merged
-   * into `form.errors`/`form.warnings` on submit and gated behind
-   * `<CheckConfirmDialog>` (mounted below) when a confirmable warning fires.
+   * Class applied to the `<form>` element itself — e.g. `flex flex-col` for a
+   * dialog taller than the viewport, so the body can scroll between a fixed
+   * header and footer.
    */
-  readonly checks?: readonly Check[];
+  readonly className?: string;
   /**
-   * Explicit check surface (`'create' | 'edit' | ...`) — forwarded to
-   * `useDeclarativeForm`'s own `surface` option. Omit to use the default
-   * create/edit inference off `value`/`defaultValue` presence; supply this
-   * whenever that heuristic is wrong for this form — most commonly, a create
-   * form that ALSO seeds `defaultValue` (e.g. `defaultValue={{ status:
-   * 'draft' }}`), which the inference alone would misread as `'edit'`. See
-   * `UseDeclarativeFormOptions.surface`'s own doc comment (`@burojs/react`)
-   * for the full rationale.
+   * Class applied to the fields region (`[data-buro-region="form-body"]`), the
+   * scroll region of a form too tall to fit (`flex-1 overflow-y-auto min-h-0`).
    */
-  readonly surface?: CheckSurface;
+  readonly bodyClassName?: string;
 }
 /**
- * Batteries-included form renderer over `useDeclarativeForm` (the headless
- * controller) and `<Field>` (the single-field brick) — design doc §4,
- * Layer 3. Uncontrolled by default: `defaultValue` seeds, internal state
- * runs, `onSubmit(values)` delivers the payload — the fast path is a real
- * one-liner, `<DeclarativeForm fields={fields} onSubmit={save} />`.
- * Controlled `value`/`onChange` remain available for the complex case.
- *
- * Renders every VISIBLE field (`form.fields` — hidden fields are already
- * excluded by the controller) with its label, its `<Field/>` (or a
- * `renderField` override), and ONE unreserved message slot: an error wins
- * the slot in `text-destructive`, else the first warning renders in
- * `text-warning-emphasis`, else nothing renders at all — mirroring
- * `resource-form.tsx`'s single-slot rule so no field can silently double its
- * layout's space, without reserving height for a message that may never
- * appear. Form-level (`field === '_form'`) errors/warnings render in their
- * own non-destructive/destructive summary above the fields. Submit is
- * disabled on `!form.canSubmit` (errors only — warnings never block) or
- * `props.disabled`.
- */
-declare function DeclarativeForm(props: DeclarativeFormProps): ReactElement;
+ * Batteries-included resource-less form (P1b+P1c decision 21) over
+ * `useFormController` and the screen renderer: the form's `body` tree (or one
+ * column of every field), each leaf with its label, input, one message slot
+ * (error over warning) and hint; a form-level error / warning summary above;
+ * the submit footer below. Uncontrolled by default (`defaults` seeds,
+ * `onSubmit(payload)` delivers the active declared values); controlled
+ * `value` / `onChange` remain available. Submit is disabled on
+ * `!form.canSubmit` (errors only — warnings never block) or `disabled`.
+ */
+declare function DeclarativeForm<F extends ResourceFieldMap = ResourceFieldMap>(props: DeclarativeFormProps<F>): ReactElement;
 //#endregion
 //#region src/forms/declarative-display.d.ts
-interface DeclarativeDisplayProps {
+interface DeclarativeDisplayProps<F extends ResourceFieldMap = ResourceFieldMap> {
   /** The same field-def map shape `defineResource`'s `f` builder produces. */
-  readonly fields: ResourceFieldMap;
+  readonly fields: F;
   /** The values to display — this renderer owns no state of its own. */
   readonly values: FormValues;
-  /** Drives label i18n and the `<FieldDisplay>` EntityRef — see `<Field>`'s own docblock. */
+  /**
+   * Drives label i18n, the doc address and the leaf ids
+   * (`<i18nPrefix>:field:<name>:hint` / `:info`). Default `'form'`.
+   */
   readonly i18nPrefix?: string;
-  /** Simple column-count switch. Defaults to a single column. */
-  readonly layout?: 'single' | 'two-column';
+  /**
+   * The display's tree, as `<DeclarativeForm body>`; absent, every field in
+   * one column, in declaration order. A field under a `when` that does not
+   * hold over `values` is not shown.
+   */
+  readonly body?: FormBody<F>;
 }
 /**
- * Read-only VIEW renderer over `<FieldDisplay>` (Task 1) — design doc §4,
- * Layer 3, the "view" corner of the read/edit/locked distinction:
- * **edit** (`<DeclarativeForm>`), **locked** (`<DeclarativeForm disabled>` —
- * inputs, disabled), **view** (this — display components, never inputs).
- *
- * Deliberately does NOT pull in `useDeclarativeForm` — a view has no state,
- * no validation, no submit lifecycle, so there is nothing for a controller
- * instance to own here. It IS, however, a thin map over the exact same
- * conditional-visibility resolution the controller runs internally
- * (`resolveFieldFlags` + `useOptionalVisibilityCtx`, `@burojs/react`,
- * Task 4) — reused as-is, not reimplemented, so a field hidden in
- * `<DeclarativeForm>` is hidden here too for the same values snapshot.
- *
- * Renders every visible field, in `fields` declaration order, as a label
- * plus `<FieldDisplay/>` — mirroring `<DeclarativeForm>`'s own per-field
- * layout (label above the field's node) minus the parts a view has no use
- * for (required marker, error/warning slot, submit).
+ * Read-only VIEW of a resource-less field map (P1b+P1c S3e): the
+ * read/edit/locked distinction's "view" corner — **edit** is
+ * `<DeclarativeForm>`, **locked** `<DeclarativeForm disabled>` (inputs,
+ * disabled), **view** this (displays, never inputs). Driven by the form
+ * controller in `show` mode over `values`, rendered through the same screen
+ * renderer, so a field hidden by a `when` in `<DeclarativeForm>` is hidden here
+ * too for the same values.
  */
-declare function DeclarativeDisplay(props: DeclarativeDisplayProps): ReactElement;
+declare function DeclarativeDisplay<F extends ResourceFieldMap = ResourceFieldMap>(props: DeclarativeDisplayProps<F>): ReactElement;
 //#endregion
 //#region src/export/export-dialog.d.ts
 interface ExportDialogProps {
@@ -2570,7 +2644,11 @@ interface ExportDialogProps {
   readonly onOpenChange: (open: boolean) => void;
   readonly resource: string;
   readonly target: ExportTarget;
-  /** The list's currently visible columns — what "as in table" (the default) sends as `request.columns`. */
+  /**
+   * The list's currently visible columns — what "as in table" (the default) sends as `request.columns`.
+   * Empty means "unknown": the dialog then sends the same set as "All columns" (the resource's list
+   * fields, minus any a `column` rule hides). `request.columns` is never omitted.
+   */
   readonly visibleColumns: readonly string[];
   /** Known row estimate, shown in the filter-scope title and handed to the exporter as a progress total hint. */
   readonly estimatedCount?: number;
@@ -2580,14 +2658,15 @@ interface ExportDialogProps {
  * unregistered `UIPresentRequest.component` registry key silently renders
  * `null`, so a framework-owned dialog would do nothing until every adopter
  * registered it (see `packages/react/src/ui/ui-presentations.tsx:74,138`).
- * `formModal` actions draw the identical line — self-hosted, built on the
- * local `<Dialog>` primitives, no registry involved.
+ * The flow host draws the opposite line (it IS presented, as `buro:flow`, and
+ * `shadcnPresentationHosts` registers it); this dialog stays self-hosted, built
+ * on the local `<Dialog>` primitives, no registry involved.
  *
  * A `mode` state (`'form' | 'progress' | 'confirm-close'`) swaps content
  * inside ONE `<DialogContent>`/one Radix focus scope. A second, nested
  * Radix root for the close-while-running confirm was tried elsewhere in this
- * codebase and deadlocked the jsdom test runner
- * (`packages/ui-shadcn/src/actions/action-button.tsx:114-127`) — this dialog
+ * codebase and deadlocked the jsdom test runner (the old form-modal action's
+ * menu-held dialog, deleted in P4) — this dialog
  * never repeats that shape.
  */
 declare function ExportDialog({ open, onOpenChange, resource, target, visibleColumns, estimatedCount }: ExportDialogProps): React$1.ReactElement;
@@ -2808,7 +2887,7 @@ declare function EnumPicker({ enumName, value, onChange, renderAs, name, id, tes
 //#region src/primitives/button.d.ts
 declare const buttonVariants: (props?: ({
   variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
-  size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+  size?: "sm" | "lg" | "default" | "icon" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
   asChild?: boolean;
@@ -2860,40 +2939,12 @@ interface ActionButtonProps {
   children?: React.ReactNode;
   /**
    * Render the action as a `<DropdownMenuItem>` (icon + label) instead of a
-   * standalone `<Button>`, for use inside an overflow `…` menu. Every action
-   * kind keeps its full behavior: confirm dialogs and formModals stay mounted
-   * (the menu is held open while they show), links navigate, and modal actions
-   * open through the framework's `UIPresentationRuntime` (`useUIPresent`).
+   * standalone `<Button>`, for use inside an overflow `…` menu. Links navigate,
+   * modal actions open through the framework's `UIPresentationRuntime`
+   * (`useUIPresent`), and a flow hands its run to a runner outside the menu.
    * Destructive actions get destructive item styling.
    */
   asMenuItem?: boolean;
-  /**
-   * Menu-mode only. Called instead of running the action directly, so the
-   * OWNER of the menu (`ActionOverflow`) can run the check gate and mount its
-   * dialog outside the dropdown (see {@link ActionConfirmRunner}). Called
-   * unconditionally — not only when the action carries a `confirm` — because
-   * a conditional check (Task 10) can fire with no `confirm` at all and still
-   * needs the dialog; `ActionConfirmRunner` is where that gate actually runs.
-   * Without it, a confirming or check-gated action rendered as a menu item
-   * cannot prompt (see {@link ActionConfirmDialog} for why the dialog must
-   * not live inside the menu).
-   */
-  onRequestConfirm?: () => void;
-  /**
-   * Menu-mode only, and the exact analogue of {@link onRequestConfirm} for
-   * `formModal` actions: called instead of opening the form, so the OWNER of
-   * the menu (`ActionOverflow`) mounts the Dialog OUTSIDE the dropdown.
-   *
-   * Without it, a formModal item had to render its own `<Dialog>` inside
-   * `DropdownMenuContent` and hold the menu open with `onSelect`'s
-   * `preventDefault()` so the dialog's own subtree wasn't torn down. That nests
-   * two Radix focus scopes (menu + dialog) inside one another: in a browser
-   * focus ping-pongs between them and typing into the form is unreliable; under
-   * jsdom the same construction deadlocked the test runner. The confirm dialog
-   * had this identical bug and was fixed the identical way — see
-   * {@link ActionConfirmRunner}.
-   */
-  onRequestForm?: () => void;
 }
 /**
  * A denial the rule asked to SHOW.
@@ -2905,9 +2956,8 @@ interface ActionButtonProps {
  * a tooltip: the click is already intercepted, so one path serves mouse,
  * keyboard and assistive tech alike.
  *
- * Shared by every leaf renderer (`LinkActionButton` / `HandlerActionButton` /
- * `ModalActionButton` / `FormModalActionButton`) rather than reimplemented in
- * each — one component, both shapes (`asMenuItem` switches between a standalone
+ * Shared by every leaf renderer (`LinkActionButton` / `ModalActionButton` /
+ * the flow button) rather than reimplemented in each — one component, both shapes (`asMenuItem` switches between a standalone
  * `<Button>` and a `<DropdownMenuItem>`).
  *
  * Exported (not a package-private leaf) because a `disabled` `Availability` is
@@ -2929,7 +2979,7 @@ interface DisabledActionProps {
   asMenuItem?: boolean;
   /**
    * Resource the denial belongs to — scopes the reason/fallback key lookup the
-   * same way `ResourceForm`'s field-lock reason is scoped, so a resource can
+   * same way the record form's field-lock reason is scoped, so a resource can
    * override the generic wording via `resources.<res>.<key>`.
    */
   resource?: string;
@@ -2952,41 +3002,6 @@ interface DisabledActionProps {
   surface?: string;
 }
 declare function DisabledAction({ reason, label, icon, testid, size, variant, className, asMenuItem, resource, density, actionName, surface }: DisabledActionProps): React.ReactElement;
-interface ActionConfirmDialogProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  title: React.ReactNode;
-  message: string;
-  isDestructive?: boolean;
-  busy?: boolean;
-  onConfirm: () => void;
-  /** Base testid; the dialog and its two buttons suffix `:confirm[-ok|-cancel]`. */
-  testid: string;
-  /**
-   * Label for the confirming button. Prefer the action's own VERB («Выполнить»)
-   * over a neutral «ОК»: a button that repeats what is about to happen is
-   * readable at a glance and matches the delete dialog, which already confirms
-   * with «Удалить». Falls back to the generic wording when absent.
-   */
-  confirmLabel?: React.ReactNode;
-}
-/**
- * The confirm prompt shown before a confirming action runs.
- *
- * @deprecated Nothing in `@burojs/ui-shadcn` mounts this any more — both
- * action call sites went through `useCheckGate` + `<CheckConfirmDialog>`,
- * which carries the same affordances (`title`, `proceedLabel`, `tone`) and
- * merges `action.confirm` with any firing check into ONE dialog. Still
- * exported for a host that already depends on it directly.
- *
- * Deliberately a standalone component so it can be mounted OUTSIDE a
- * `<DropdownMenuContent>`. Rendering a Radix Dialog inside an open Radix menu
- * mounts two focus scopes / dismissable layers at once, which fight over focus
- * (a hard deadlock under jsdom, broken dismiss behavior in a real browser) and
- * risks the dialog being torn down with the menu. `ActionOverflow` therefore
- * owns one of these as a SIBLING of the menu; see {@link ActionConfirmRunner}.
- */
-declare function ActionConfirmDialog({ open, onOpenChange, title, message, isDestructive, busy, onConfirm, testid, confirmLabel }: ActionConfirmDialogProps): React.ReactElement;
 declare function ActionButton(props: ActionButtonProps): React.ReactElement | null;
 //#endregion
 //#region src/actions/action-overflow.d.ts
@@ -3002,6 +3017,16 @@ interface ActionOverflowProps {
    */
   surface: string;
   className?: string;
+  /**
+   * Flows this screen presents inline (P6 3.12): their own button is not drawn here, the
+   * placement is their control on this screen.
+   */
+  hideFlows?: (name: string) => boolean;
+  /**
+   * A row in a narrow list: every action goes into the one menu, so the actions column is a single
+   * control wide. Default: {@link RowActionsCollapseContext}.
+   */
+  collapse?: boolean;
 }
 /**
  * Collapses an entity's actions into an overflow menu so tables and detail
@@ -3013,14 +3038,14 @@ interface ActionOverflowProps {
  * own control (at their resolved density — icon-only on a row, icon+label on
  * a toolbar); everything else collapses into one menu after them, with the
  * destructive tail set off by a separator. Menu items reuse
- * `<ActionButton asMenuItem>` so every action kind (handler / confirm / link /
- * modal / formModal) keeps working from inside the dropdown. Tone is NOT
+ * `<ActionButton asMenuItem>` for a link or a modal and `<FlowMenuItem>` for a
+ * flow, whose run continues outside the dropdown. Tone is NOT
  * hardcoded here (no more `variant="ghost"`): it comes from each action's own
  * `variant`, exactly like the menu items already respected it — a hardcoded
  * `ghost` used to strip a destructive standalone action of its destructive
  * look.
  */
-declare function ActionOverflow({ resource, record, surface, className }: ActionOverflowProps): React.ReactElement | null;
+declare function ActionOverflow({ resource, record, surface, className, hideFlows, collapse }: ActionOverflowProps): React.ReactElement | null;
 //#endregion
 //#region src/actions/action-surface.d.ts
 /**
@@ -3063,6 +3088,12 @@ interface BulkActionToolbarProps<TRecord extends BulkRecord = BulkRecord> {
    * itself via `table.resetRowSelection()`.
    */
   onClearSelection?: () => void;
+  /**
+   * Replaces the selection. A bulk flow calls it after its run: the ids that succeeded leave the
+   * selection and the others stay (P4 spec 4.16). Without it, a run that succeeded for every id
+   * clears the selection through `onClearSelection`.
+   */
+  onSelectionChange?: (ids: string[]) => void;
   className?: string;
   /**
    * The list's currently visible columns (Task 8) — forwarded to the
@@ -3070,33 +3101,81 @@ interface BulkActionToolbarProps<TRecord extends BulkRecord = BulkRecord> {
    * what "as shown in the table" (the dialog's default) sends as
    * `request.columns`. Optional: this toolbar is usable standalone, with no
    * `<ResourceListPage>`/list controller in reach — a caller that omits it
-   * gets an empty projection for that default, same as any other prop this
-   * component has no way to infer on its own.
+   * gets the dialog's "All columns" set for that default: the resource's list
+   * fields, minus any a `column` rule hides.
    */
   visibleColumns?: readonly string[];
 }
-declare function BulkActionToolbar<TRecord extends BulkRecord = BulkRecord>({ resource, table, selectedRecords, selectedIds, onClearSelection, className, visibleColumns }: BulkActionToolbarProps<TRecord>): React.ReactElement | null;
+declare function BulkActionToolbar<TRecord extends BulkRecord = BulkRecord>({ resource, table, selectedRecords, selectedIds, onClearSelection, onSelectionChange, className, visibleColumns }: BulkActionToolbarProps<TRecord>): React.ReactElement | null;
 //#endregion
-//#region src/actions/dispatcher-context.d.ts
-interface DispatcherProviderProps {
-  dispatcher: Dispatcher;
-  children: ReactNode;
+//#region src/flows/flow-action-button.d.ts
+interface FlowActionButtonProps {
+  readonly resource: string;
+  /** The flow's name in the resource's `actions`. */
+  readonly actionName: string;
+  readonly record?: {
+    id: string;
+  } & Record<string, unknown>;
+  /** The surface (`'row'`, `'show'`, …): the test id's namespace, as `ActionButton`'s. */
+  readonly scope?: string;
+  readonly asMenuItem?: boolean;
+  readonly density?: ActionDensity;
+  readonly variant?: ButtonProps['variant'];
+  readonly size?: ButtonProps['size'];
+  readonly className?: string;
+  readonly children?: ReactNode;
+}
+/**
+ * A flow's button or menu item (P4 spec 4.15, 4.17). The control is decided without a run — the
+ * flow's gate (undecided while permissions load), the page's one batched read on a row (I8), its
+ * `when` and pre-click checks — so the flow machine is not in the first screen. A hover or a
+ * focus starts loading the flow runtime; the click (at the latest) starts the run, whose `with`
+ * sources load then: until it has decided, the control is busy and a second click does nothing,
+ * so one click sends at most once.
+ */
+declare function FlowActionButton(props: FlowActionButtonProps): ReactElement | null;
+//#endregion
+//#region src/flows/app-flow-button.d.ts
+interface AppFlowButtonProps {
+  /** The entry `useAppActions()` returned for a `kind: 'flow'` app action. */
+  readonly action: {
+    readonly name: string;
+    readonly label: string;
+    readonly icon?: string;
+    readonly disabledReason?: string;
+    /** A flow hosted on a custom page (P7 3.15): the control is a link to it, not a runner. */
+    readonly hostHref?: string;
+  };
+  readonly variant?: ButtonProps['variant'];
+  readonly size?: ButtonProps['size'];
+  readonly className?: string;
 }
-declare function DispatcherProvider({ dispatcher, children }: DispatcherProviderProps): React.ReactElement;
-declare function useDispatcher(): Dispatcher;
+/**
+ * An app flow's control (P4-D: app flows are drawn). `useAppActions()` decides whether the
+ * entry exists and whether it is disabled (the flow's gate); this button draws it, loads the
+ * flow runtime on intent (a hover, a focus, at the latest the click) and runs the flow — its
+ * host when it has a form or a review, else the send behind the confirm dialog. Busy from the
+ * click until the interaction ends. Test id: `app-action:<name>`.
+ */
+declare function AppFlowButton({ action, variant, size, className }: AppFlowButtonProps): ReactElement;
 //#endregion
 //#region src/checks/check-confirm-dialog.d.ts
 interface CheckConfirmDialogProps {
   readonly state: CheckGateState;
-  /** Base testid; the dialog and its rows suffix `:dialog`, `:proceed`, `:cancel`, `:item:<checkId>`. */
+  /**
+   * Base testid; the dialog and its rows suffix `:dialog`, `:proceed`,
+   * `:cancel`, `:item:<checkId>`.
+   */
   readonly testid: string;
-  /** Fired (before `state.cancel()`) when an anchored row — `path[0]` is a field name — is clicked. */
+  /**
+   * Fired (before `state.cancel()`) when an anchored row — `path[0]` is a
+   * field name — is clicked.
+   */
   readonly onAnchorFocus?: (field: string) => void;
   /**
    * Overrides the neutral `checks.dialogTitle` heading. The ACTION call sites
-   * pass the action's own label here (the standalone `ActionConfirmDialog`
-   * this component replaced used it as its title), so «Архивировать» still
-   * heads an archive prompt instead of a generic "please review".
+   * pass the action's own label here, so «Архивировать» heads an archive
+   * prompt instead of a generic "please review".
    */
   readonly title?: ReactNode;
   /**
@@ -3115,12 +3194,10 @@ interface CheckConfirmDialogProps {
 }
 /**
  * Renders `useCheckGate`'s `state` — one dialog for `action.confirm`
- * headers, blocking checks and confirmable warnings alike (Task 6's
- * contract). Structured after `ActionConfirmDialog`
- * (`packages/ui-shadcn/src/actions/action-button.tsx`): controlled
- * `<Dialog>`, same focus-restore-on-close effect, `data-testid` on the
- * content and both buttons — Task 10 folds the two into one dialog, and
- * staying close in shape/behaviour here is what keeps that merge cheap.
+ * headers, blocking checks and confirmable warnings alike — since P4 the
+ * only confirm dialog an action has (a flow's `confirm` lowers to a check):
+ * a controlled `<Dialog>` with a focus-restore-on-close effect and a
+ * `data-testid` on the content and both buttons.
  *
  * Blockers ('error' severity) are shown first, under `checks.blocked`, and
  * NEVER get a proceed button — `state.proceed()` already no-ops while
@@ -3295,10 +3372,17 @@ interface DataTableProps<TRow> {
    * (except an interactive element — link, button, checkbox, kebab — or while
    * selecting text) navigates to `rowHref(row)`. Cmd/Ctrl-click and middle-click
    * open it in a NEW TAB, matching native link behaviour. Client-side nav uses
-   * the injected `useNavigate()`. The row's own ID cell stays a real anchor for
-   * keyboard / copy-link, so this is a mouse-affordance layer on top.
+   * `useRouteNavigate()` (the `RouterAdapter`). The row's own ID cell stays a
+   * real anchor for keyboard / copy-link, so this is a mouse-affordance layer on
+   * top.
    */
   rowHref?: (row: TRow) => string | undefined;
+  /**
+   * A row opener asked before `rowHref` on a plain click (P3-17): `true` means it handled the
+   * row (a quick entry opened) and the row does not navigate. A modified click (Cmd/Ctrl,
+   * middle) still opens `rowHref` in a new tab.
+   */
+  onRowOpen?: (row: TRow) => boolean;
   /**
    * Enable drag-to-reorder on column headers (#17). When set, headers become
    * draggable and dropping one onto another calls `onColumnReorder(from, to)`.
@@ -3317,7 +3401,7 @@ interface DataTableProps<TRow> {
   selectionColumnId?: string;
   className?: string;
 }
-declare function DataTable<TRow>({ table, tableTestId, getRowTestId, getCellTestId, isLoading, loadingRowCount, emptyState, errorState, rowClassName, ariaLabel, onColumnReorder, rowHref, selectionColumnId, className }: DataTableProps<TRow>): React.ReactElement;
+declare function DataTable<TRow>({ table, tableTestId, getRowTestId, getCellTestId, isLoading, loadingRowCount, emptyState, errorState, rowClassName, ariaLabel, onColumnReorder, rowHref, onRowOpen, selectionColumnId, className }: DataTableProps<TRow>): React.ReactElement;
 //#endregion
 //#region src/data-table/data-table-faceted-filter.d.ts
 /**
@@ -3769,9 +3853,7 @@ declare function ListSearchInput({ resource, label, value, onCommit, placeholder
    * default: `<ResourceListPage>` distinguishes a declarative
    * `views.list.search` (names its first field) from a resolver (generic
    * `list.search` label, since the framework cannot know what a resolver
-   * matches — see `RelationTab.search`'s note on why there is no numeric-id
-   * branch), and the embedded sub-resource tab always names its one
-   * `contains` field.
+   * matches), and a `related-list` placement names its own search field.
    */
   placeholder?: string;
 }): import("react/jsx-runtime").JSX.Element;
@@ -3818,145 +3900,396 @@ declare function ColumnsToggle({ resource, def, allAvailable, required, visibleC
   onRestoreDefaults?: () => void;
 }): import("react/jsx-runtime").JSX.Element;
 //#endregion
-//#region src/list-kit/cursor-load-more.d.ts
-/**
- * Props of {@link CursorLoadMore}.
- *
- * Deliberately shaped as three scalars rather than taking the controller's
- * `cursor` group whole: the group's `next` is an opaque TOKEN (useful to a
- * consumer that wants to log or deep-link it) while this control only ever
- * needs to know whether there IS one. Spreading `cursor` in would also make
- * the component unusable by a surface that paginates a nested/embedded list
- * outside `useResourceList` — the workflows page does exactly that.
- */
-interface CursorLoadMoreProps {
-  /** Render the button at all. `false` renders nothing (see the docblock). */
-  hasMore: boolean;
-  /** A load-more fetch is in flight — disables the button and swaps the label. */
-  loading?: boolean;
-  /** Fetch the next page. Wire to `cursor.loadMore()`. */
-  onMore: () => void;
-}
-/**
- * The "load more" footer for a **cursor (opaque-token) paginated** list —
- * the counterpart of the numbered pager `<ResourceList>` renders for offset
- * providers.
- *
- * ```tsx
- * const { rows, cursor } = useResourceListContext();
- * // …the table…
- * {cursor && (
- *   <CursorLoadMore
- *     hasMore={cursor.next !== null}
- *     loading={cursor.isLoadingMore}
- *     onMore={cursor.loadMore}
- *   />
- * )}
- * ```
- *
- * ⚠️ **Renders `null` when `hasMore` is false**, so an exhausted cursor
- * leaves no dead control behind — the caller does not need its own guard.
- * That is also what makes "the button is gone" a usable end-of-list
- * assertion in tests.
- *
- * Why it lives in the framework rather than in the app that first needed it
- * (core flexibility program, Task B5.3): it has **zero coupling to any
- * provider**. It knows nothing about Temporal, tokens, or where the next
- * page comes from — only "is there more" / "is it coming" / "go get it". A
- * cursor list is now a first-class declared mode
- * (`views.list.pagination: 'cursor'`), so the control that drives one
- * belongs beside the pager it replaces.
- *
- * @see ResourceListController.cursor in `@burojs/react`
- */
-declare function CursorLoadMore({ hasMore, loading, onMore }: CursorLoadMoreProps): React.ReactElement | null;
+//#region src/list-kit/pieces/list-body.d.ts
+declare const ListBody: () => ReactElement | null;
 //#endregion
-//#region src/list-kit/resource-list-page.d.ts
+//#region src/list-kit/pieces/list-bulk-bar.d.ts
+declare const ListBulkBar: () => ReactElement | null;
+//#endregion
+//#region src/list-kit/pieces/list-columns.d.ts
+declare const ListColumns: () => ReactElement | null;
+//#endregion
+//#region src/list-kit/pieces/list-controls.d.ts
 /**
- * Props of {@link ResourceListPage}.
+ * The toolbar as a frame places it (`<ListControls/>`): under `checkFrame` it draws the pieces it
+ * is made of, so a frame that also places one of them is counted twice.
  */
-interface ResourceListPageProps {
+declare function ListControls(): ReactElement | null;
+//#endregion
+//#region src/list-kit/pieces/list-create.d.ts
+declare const ListCreate: () => ReactElement | null;
+//#endregion
+//#region src/list-kit/pieces/list-export.d.ts
+declare const ListExport: () => ReactElement | null;
+//#endregion
+//#region src/list-kit/pieces/list-filters.d.ts
+declare const ListFilters: () => ReactElement | null;
+//#endregion
+//#region src/list-kit/pieces/list-flows.d.ts
+declare const ListFlows: () => ReactElement | null;
+//#endregion
+//#region src/list-kit/pieces/list-live.d.ts
+declare const ListLive: () => ReactElement | null;
+//#endregion
+//#region src/list-kit/pieces/list-saved-views.d.ts
+declare const ListSavedViews: () => ReactElement | null;
+//#endregion
+//#region src/resource/resource-list.d.ts
+type RowRecord$1 = {
+  id: string;
+} & Record<string, unknown>;
+interface ResourceListProps {
+  resource: string;
+  data?: RowRecord$1[];
+  total?: number;
+  page?: number;
+  pageSize?: number;
   /**
-   * Registry name of the resource to list.
-   *
-   * ⚠️ **Precondition: it MUST be registered.** `useResourceList` resolves
-   * `routing.createHref` through `hrefFor`, which throws `unknown node
-   * '<resource>'` for a name the registry doesn't know. Route-level code
-   * should 404 before mounting this component (the playground's
-   * `app/(admin)/[resource]/page.tsx` does exactly that).
+   * Called when the user picks a different page size. The size selector is
+   * rendered ONLY when this is supplied — a list whose host does not persist
+   * page size should not offer a control that silently resets on navigation.
    */
-  resource: string;
+  onPageSize?: (size: number) => void;
   /**
-   * Extra `meta` merged into the underlying `useList` call — and therefore
-   * into the react-query cache key. This is the seam for app-level query
-   * scope the framework cannot know about: a sidebar product-group /
-   * location picker, a tenant id, anything a data provider turns into a
-   * server-side `where`.
+   * Ask the host for the row count of the CURRENTLY described set (Task
+   * B4.3). Rendered ONLY when this is supplied and `total` is unknown — the
+   * same "no control the host cannot honour" gate `onPageSize` above uses.
    *
-   * ⚠️ **The caller MUST memoize this object.** It flows into the query key
-   * AND into the controller's own memo chain; an inline object literal
-   * mints a fresh key on every render, which busts that chain and can
-   * produce a refetch loop. The playground memoizes on
-   * `[scope.productGroup, scope.locationId]`:
+   * This component is presentational by contract, so the trigger arrives as
+   * a prop rather than being read from `useResourceListContext()`:
+   * `useResourceListContext()` THROWS outside a provider
+   * (`list-kit/context.tsx`), and `<ResourceList>` must stay usable
+   * standalone — a `related-list` placement mounts one with a hand-rolled count and
+   * no controller at all.
    *
-   * ```tsx
-   * const scope = useScope();
-   * const listMeta = useMemo(
-   *   () => ({ scope: { pg: scope.productGroup, location_id: scope.locationId } }),
-   *   [scope.productGroup, scope.locationId],
-   * );
-   * return <ResourceListPage resource={resource} meta={listMeta} />;
-   * ```
+   * ⚠️ Answering moves the user, on purpose. The host writes the answer into
+   * `total`, which flips `knownTotal` and with it four behaviours that are
+   * dead on an unknown-total list: `pagination.showing` replaces the
+   * range-only readout, the first/last jump buttons appear, `hasNextPage`
+   * switches from "this page is full" to `page < totalPages`, and the
+   * out-of-range clamp navigates a stale `?page=20` to the last real page.
+   * That last one is the point of offering the trigger on a wrong page at
+   * all.
    */
-  meta?: Record<string, unknown>;
+  onRequestCount?: () => void;
   /**
-   * App-level per-cell renderer, consulted AFTER this component's own
-   * built-in branches (template discriminator → declared `enum` field) and
-   * BEFORE `<ResourceList>`'s default field-type display. Return
-   * `undefined` to fall through, exactly like `<ResourceList renderCell>`.
-   *
-   * The built-ins cover what the registry can describe on its own; this
-   * prop is for the rest — the playground uses it for a legacy hardcoded
-   * `status` badge and a `is_active` Yes/No badge, neither of which the
-   * framework can derive from a field def.
-   *
-   * ⚠️ Wins over a registered `list.cell.<resource>` slot (level 1 —
-   * {@link ../list-kit/list-slots.js | listSlot}). A host that mounted this
-   * page by hand and passed its own `renderCell` knows more than the
-   * registry does; the slot exists for the standard router, which mounts
-   * `<ResourceListPage resource={...}>` with no props at all.
-   *
-   * ⚠️ Same purity requirement as `<ResourceList renderCell>`: it runs
-   * inside a memoized cell, so anything depending on external reactive
-   * state (locale, flags) must be delegated to a component that
-   * subscribes to that state itself.
+   * A count request is in flight. The trigger keeps its place and its width;
+   * only its label is swapped for a spinner, and it stops accepting clicks.
    */
-  renderCell?: (col: string, value: unknown, row: RowRecord) => ReactNode | undefined;
+  isCountingRows?: boolean;
+  /** Page-size choices. Defaults to a standard admin ladder. */
+  pageSizeOptions?: number[];
+  onPage?: (n: number) => void;
   /**
-   * Replacement for the table's empty state, forwarded to
-   * `<ResourceList emptyState>` and from there to `<DataTable emptyState>`.
+   * Opaque-token pagination. When supplied, the numbered pager is replaced by
+   * a load-more control: a token list has no page index to jump to. Absent →
+   * the offset pager renders exactly as before.
+   */
+  loadMore?: {
+    hasMore: boolean;
+    loading: boolean;
+    onMore: () => void;
+  };
+  selectable?: boolean;
+  /**
+   * Accumulating selection owned by the caller. When provided the component
+   * is CONTROLLED: this is the WHOLE selected set (ids that are not on the
+   * current page included), the component keeps no selection state of its
+   * own, and every change — including the page-scoped header checkbox — is
+   * reported through `onSelectionChange` as the new whole set.
    *
-   * ⚠️ Supplying this changes the SHAPE of the empty list, not just its
-   * copy: the default is a standalone panel rendered INSTEAD of the table
-   * (dashed border, icon, heading, and a "Clear filter" / "+ Create" /
-   * "back to page 1" CTA), whereas a supplied node renders inside the
-   * table body, so the header row survives and the CTAs do not. Pass one
-   * when a slot wants the table chrome to stay put; omit it for the
-   * standard panel.
+   * Omit it for the uncontrolled behaviour: the component owns the selection
+   * and drops it whenever `data` changes identity.
+   *
+   * ⚠️ A controlled caller MUST commit every emission it receives through
+   * `onSelectionChange` back into this prop: skip one and the `emittedRef`
+   * bridge (below) stays armed against a base the DOM never reflected, so
+   * the next toggle composes against a phantom selection instead of what's
+   * actually checked.
    */
-  emptyState?: ReactNode;
-}
-/**
- * The assembled, data-connected list page (core flexibility program, Task
- * B3.1) — the piece that makes `<ResourceList>` actually useful. Given a
- * resource name it renders the whole standard list surface:
- *
- *  - page header,
- *  - the filter region — search box + pinned controls + the filter-builder
- *    popover + applied-filter badges + "Clear all" (via {@link FilterRegion}),
- *  - saved-views dropdown and its two dialogs (save-current / manage),
- *  - the columns toggle and the create button,
- *  - `<ResourceList>` itself (table, empty/error/loading states,
+  selectedIds?: string[];
+  onSelectionChange?: (ids: string[]) => void;
+  className?: string;
+  /** When true, show skeleton rows instead of the table. */
+  isLoading?: boolean;
+  /** When non-null, show an error state. */
+  error?: {
+    message: string;
+  } | Error | null;
+  /**
+   * Optional retry callback. When provided AND `error` is set, the
+   * error-state panel renders a "Retry" button that invokes this
+   * callback. The typical wiring is `onRetry={() => query.refetch()}`
+   * when the parent uses the framework's `useList` (or an equivalent
+   * `refetch()` method on the data source).
+   */
+  onRetry?: () => void;
+  /** Render an inline "+ Create" button in the empty state. */
+  createHref?: string;
+  /** Whether the list is currently filtered (changes empty-state copy). */
+  isFiltered?: boolean;
+  /** Called when the user clicks the "Clear filter" link in the filtered-empty state. */
+  onClearFilter?: () => void;
+  /**
+   * Replacement for the "no rows" rendering, forwarded to
+   * `<DataTable emptyState>`.
+   *
+   * ⚠️ This changes the SHAPE of the empty list, not just its copy. Left
+   * undefined (the default, and what every caller did before the slot work)
+   * this component early-returns a standalone panel INSTEAD of the table —
+   * dashed border, icon, heading, and one of three CTAs ("Clear filter" when
+   * filtered / "+ Create" when genuinely empty / "back to page 1" on an
+   * out-of-range page). Supplying a node skips that panel entirely: the
+   * table renders with its header row and the node fills a single body cell
+   * spanning every column, so the column headers survive but none of the
+   * CTAs do — the caller owns whatever recovery affordance the state needs.
+   *
+   * The footer/pagination is still hidden while there are no rows.
+   */
+  emptyState?: React.ReactNode;
+  /**
+   * Another drawing of the same rows in place of the table (a `related-list` with `view: 'cards'`
+   * or `'timeline'`, P6 3.13). Everything around the rows stays this component's: the loading,
+   * error and empty states, the numbered pager or load-more footer, the on-demand count. The
+   * table's own affordances (selection, column menu, sort headers) do not exist on it.
+   */
+  rowsView?: {
+    readonly render: (rows: RowRecord$1[]) => React.ReactNode;
+    /** Drawn while the first page loads, in place of the table skeleton. */
+    readonly skeleton: React.ReactNode;
+  };
+  /**
+   * If provided, each row becomes a clickable link to this href.
+   * Receives the row record; returns the navigation target.
+   * Default behavior: rows are not clickable. Set to `(row) => '/{resource}/{row.id}'`
+   * for typical show-page navigation.
+   */
+  rowHref?: (row: RowRecord$1) => string | undefined;
+  /**
+   * A row's quick opener (P3-17): when it returns a function, a plain click on the row or its
+   * first cell calls it instead of navigating; the first cell keeps the `rowHref` anchor (marked
+   * for the opener) when there is one, and is a button when there is none. `null`: the row
+   * follows `rowHref`.
+   */
+  rowQuick?: (row: RowRecord$1) => (() => void) | null;
+  /**
+   * Changes whenever `rowHref` or `rowQuick` would answer differently for the same row (an
+   * access answer arrived): the memoized rows and cells re-render.
+   */
+  rowLinkKey?: unknown;
+  /**
+   * Per-cell custom renderer override. Returns `undefined` to fall back to
+   * the default field-type-based display. Use for badges, links, or any
+   * custom visual treatment that depends on column + value + row.
+   *
+   * MUST be a pure function of `(col, value, row)` — the cell it renders runs
+   * inside `<DataTable>`'s memoized row/cell (`MemoRow`/`MemoCell` in
+   * data-table.tsx), which intentionally skips re-rendering when a row's own
+   * data and selection state haven't changed. If the returned output depends
+   * on EXTERNAL reactive state (locale, a feature flag, anything read outside
+   * `col`/`value`/`row`), it will go stale under that memo the same way the
+   * built-in `DateDisplay`/`NumberDisplay` renderers did before they were
+   * fixed to self-subscribe to locale. Delegate any such state-dependent
+   * text to a component that subscribes to it itself (`useLocale()` /
+   * `useOptionalT()` — see `EnumDisplay`/`BooleanDisplay`/`DateDisplay` for
+   * the pattern) rather than resolving it inline in this callback.
+   */
+  renderCell?: (col: string, value: unknown, row: RowRecord$1) => React.ReactNode | undefined;
+  /** Current native sort expression. The header exposes the first sort key. */
+  sort?: readonly {
+    field: string;
+    direction: 'asc' | 'desc';
+  }[];
+  /**
+   * Sort request from a column header. `direction` is EXPLICIT when the header
+   * menu picks «по возрастанию/убыванию/сбросить» (`'asc'`/`'desc'`/`null`); it
+   * is omitted when a caller wants the legacy 3-click toggle. Consumers should
+   * honour an explicit direction and fall back to toggling when it's undefined.
+   */
+  onSort?: (field: string, direction?: 'asc' | 'desc' | null) => void;
+  /**
+   * Hide a column from a column-header menu. Receives the column name; the
+   * parent removes it from the visible-columns list. When omitted, the header
+   * menu shows no «hide» item.
+   */
+  onHideColumn?: (field: string) => void;
+  /**
+   * Columns that may NOT be hidden — the header menu omits «hide» for these.
+   * Without it every column is treated as hideable (when `onHideColumn` is set).
+   */
+  requiredColumns?: string[];
+  /**
+   * Bump to reset the persisted column layout (#17). `resetLayout.mode`:
+   *   - `'sizes'` — clear user-resized widths only.
+   *   - `'all'`   — clear widths AND pinning AND order back to defaults.
+   * The token is what triggers it; increment it on each reset click.
+   */
+  resetLayout?: {
+    token: number;
+    mode: 'sizes' | 'all';
+  };
+  /**
+   * Override for the column list rendered in the table. When omitted,
+   * the table falls back to `def.views.list.columns` (or all field
+   * keys). When provided, the table renders EXACTLY this set in the
+   * given order — useful for the user-toggleable Columns menu (see
+   * `views.list.optionalColumns` / `requiredColumns`).
+   */
+  columns?: string[];
+  /**
+   * Optional callback that hands the parent the underlying TanStack
+   * `Table` instance. Fires once after the table is mounted (and
+   * again with `null` on unmount). Use this when the parent needs to
+   * read selection state for components that live OUTSIDE the table
+   * (e.g. `<BulkActionToolbar>` which calls
+   * `table.getFilteredSelectedRowModel().rows`). The id-array
+   * `onSelectionChange` callback remains the recommended way to
+   * trigger a parent re-render on selection changes — `tableRef`
+   * gives access to the rows, not a re-render signal.
+   */
+  tableRef?: (table: Table$1<RowRecord$1> | null) => void;
+}
+declare function ResourceList({ resource, data, total, page, pageSize, onPageSize, onRequestCount, isCountingRows, pageSizeOptions, onPage, loadMore, selectable, selectedIds, onSelectionChange, className, isLoading, error, onRetry, createHref, isFiltered, onClearFilter, emptyState, rowsView, rowHref, rowQuick, rowLinkKey, renderCell, sort, onSort, onHideColumn, requiredColumns, resetLayout, columns: columnsOverride, tableRef }: ResourceListProps): React.ReactElement;
+//#endregion
+//#region src/list-kit/cursor-load-more.d.ts
+/**
+ * Props of {@link CursorLoadMore}.
+ *
+ * Deliberately shaped as three scalars rather than taking the controller's
+ * `cursor` group whole: the group's `next` is an opaque TOKEN (useful to a
+ * consumer that wants to log or deep-link it) while this control only ever
+ * needs to know whether there IS one. Spreading `cursor` in would also make
+ * the component unusable by a surface that paginates a nested/embedded list
+ * outside `useResourceList` — the workflows page does exactly that.
+ */
+interface CursorLoadMoreProps {
+  /** Render the button at all. `false` renders nothing (see the docblock). */
+  hasMore: boolean;
+  /** A load-more fetch is in flight — disables the button and swaps the label. */
+  loading?: boolean;
+  /** Fetch the next page. Wire to `cursor.loadMore()`. */
+  onMore: () => void;
+}
+/**
+ * The "load more" footer for a **cursor (opaque-token) paginated** list —
+ * the counterpart of the numbered pager `<ResourceList>` renders for offset
+ * providers.
+ *
+ * ```tsx
+ * const { rows, cursor } = useResourceListContext();
+ * // …the table…
+ * {cursor && (
+ *   <CursorLoadMore
+ *     hasMore={cursor.next !== null}
+ *     loading={cursor.isLoadingMore}
+ *     onMore={cursor.loadMore}
+ *   />
+ * )}
+ * ```
+ *
+ * ⚠️ **Renders `null` when `hasMore` is false**, so an exhausted cursor
+ * leaves no dead control behind — the caller does not need its own guard.
+ * That is also what makes "the button is gone" a usable end-of-list
+ * assertion in tests.
+ *
+ * Why it lives in the framework rather than in the app that first needed it
+ * (core flexibility program, Task B5.3): it has **zero coupling to any
+ * provider**. It knows nothing about Temporal, tokens, or where the next
+ * page comes from — only "is there more" / "is it coming" / "go get it". A
+ * cursor list is now a first-class declared mode
+ * (`views.list.pagination: 'cursor'`), so the control that drives one
+ * belongs beside the pager it replaces.
+ *
+ * @see ResourceListController.cursor in `@burojs/react`
+ */
+declare function CursorLoadMore({ hasMore, loading, onMore }: CursorLoadMoreProps): React.ReactElement | null;
+//#endregion
+//#region src/list-kit/resource-list-page.d.ts
+/**
+ * Props of {@link ResourceListPage}.
+ */
+interface ResourceListPageProps {
+  /**
+   * Registry name of the resource to list.
+   *
+   * ⚠️ **Precondition: it MUST be registered.** `useResourceList` resolves
+   * `routing.createHref` through `hrefFor`, which throws `unknown node
+   * '<resource>'` for a name the registry doesn't know. Route-level code
+   * should 404 before mounting this component (the playground's
+   * `app/(admin)/[resource]/page.tsx` does exactly that).
+   */
+  resource: string;
+  /**
+   * Extra `meta` merged into the underlying `useList` call — and therefore
+   * into the react-query cache key. This is the seam for app-level query
+   * scope the framework cannot know about: a sidebar product-group /
+   * location picker, a tenant id, anything a data provider turns into a
+   * server-side `where`.
+   *
+   * ⚠️ **The caller MUST memoize this object.** It flows into the query key
+   * AND into the controller's own memo chain; an inline object literal
+   * mints a fresh key on every render, which busts that chain and can
+   * produce a refetch loop. The playground memoizes on
+   * `[scope.productGroup, scope.locationId]`:
+   *
+   * ```tsx
+   * const scope = useScope();
+   * const listMeta = useMemo(
+   *   () => ({ scope: { pg: scope.productGroup, location_id: scope.locationId } }),
+   *   [scope.productGroup, scope.locationId],
+   * );
+   * return <ResourceListPage resource={resource} meta={listMeta} />;
+   * ```
+   */
+  meta?: Record<string, unknown>;
+  /**
+   * App-level per-cell renderer, consulted AFTER this component's own
+   * built-in branches (typed discriminator → declared `enum` field) and
+   * BEFORE `<ResourceList>`'s default field-type display. Return
+   * `undefined` to fall through, exactly like `<ResourceList renderCell>`.
+   *
+   * The built-ins cover what the registry can describe on its own; this
+   * prop is for the rest — the playground uses it for a legacy hardcoded
+   * `status` badge and a `is_active` Yes/No badge, neither of which the
+   * framework can derive from a field def.
+   *
+   * ⚠️ Wins over a registered `list.cell.<resource>` slot (level 1 —
+   * {@link ../list-kit/list-slots.js | listSlot}). A host that mounted this
+   * page by hand and passed its own `renderCell` knows more than the
+   * registry does; the slot exists for the standard router, which mounts
+   * `<ResourceListPage resource={...}>` with no props at all.
+   *
+   * ⚠️ Same purity requirement as `<ResourceList renderCell>`: it runs
+   * inside a memoized cell, so anything depending on external reactive
+   * state (locale, flags) must be delegated to a component that
+   * subscribes to that state itself.
+   */
+  renderCell?: (col: string, value: unknown, row: RowRecord) => ReactNode | undefined;
+  /**
+   * Replacement for the table's empty state, forwarded to
+   * `<ResourceList emptyState>` and from there to `<DataTable emptyState>`.
+   *
+   * ⚠️ Supplying this changes the SHAPE of the empty list, not just its
+   * copy: the default is a standalone panel rendered INSTEAD of the table
+   * (dashed border, icon, heading, and a "Clear filter" / "+ Create" /
+   * "back to page 1" CTA), whereas a supplied node renders inside the
+   * table body, so the header row survives and the CTAs do not. Pass one
+   * when a slot wants the table chrome to stay put; omit it for the
+   * standard panel.
+   */
+  emptyState?: ReactNode;
+}
+/**
+ * The assembled, data-connected list page (core flexibility program, Task
+ * B3.1) — the piece that makes `<ResourceList>` actually useful. Given a
+ * resource name it renders the whole standard list surface:
+ *
+ *  - page header,
+ *  - the filter region — search box + pinned controls + the filter-builder
+ *    popover + applied-filter badges + "Clear all" (via {@link FilterRegion}),
+ *  - saved-views dropdown and its two dialogs (save-current / manage),
+ *  - the columns toggle and the create button,
+ *  - `<ResourceList>` itself (table, empty/error/loading states,
  *    pagination),
  *  - the floating bulk-action bar.
  *
@@ -3969,6 +4302,11 @@ interface ResourceListPageProps {
  * — the filter region's OWN testids moved to the builder's `list-filter:*`
  * convention; everything else is unchanged).
  *
+ * It renders through the built-in `related-list` block (spec 8.4, decision 63): the view is
+ * `buro:related-list`'s, inside a `[data-buro-node="place"]` wrapper, and an app that registers
+ * its own `buro:related-list` view (`<BuroProvider blockImplementations>`) replaces this list
+ * everywhere, a development notice saying so. The body itself lives in `ResourceListSurface`.
+ *
  * The whole subtree is wrapped in `<ResourceListProvider>`, so any nested
  * component can read the live controller with `useResourceListContext()`
  * instead of receiving a hand-threaded prop chain. That is the seam the
@@ -3982,7 +4320,7 @@ interface ResourceListPageProps {
  * covers:
  *
  * - **`list.cell.<resource>`** (level 1) is consulted for every cell, AFTER
- *   this component's own built-in branches (template discriminator →
+ *   this component's own built-in branches (typed discriminator →
  *   declared `enum` field) and BEFORE `<ResourceList>`'s default field-type
  *   display — the same position the `renderCell` prop occupies, and the
  *   explicit prop wins when both are present. Everything else — filters,
@@ -3991,17 +4329,13 @@ interface ResourceListPageProps {
  *   the search box, the pinned controls, the filter-builder popover and its
  *   applied-filter badges. Saved views, the columns toggle, the create
  *   button, the table, the footer and pagination all stay standard.
- * - **`list.body.<resource>`** (level 3) replaces everything below the
- *   page header: the whole toolbar row, the saved-view dialogs, the
- *   table, the footer and the bulk bar.
- *
- * ⚠️ Level 3 keeps the `<PageHeader>` deliberately. It is what writes
- * `document.title` (via `useDocumentTitle`, defended against Next's
- * metadata re-application) and what renders the page's accessible `<h1>`
- * and its breadcrumb slot — and the spec's level-3 guarantee is that
- * routing, data loading, redirects and BREADCRUMBS stay framework-owned:
- * "you lose only the default assembled markup". A slot that wants a
- * visible heading of its own renders one; the header's `h1` is `sr-only`.
+ * - A whole-body override is a list frame (`views.list.frame`, P7-34), which arranges the
+ *   framework's pieces and keeps the page header, the controller, the URL state, the saved-view
+ *   dialogs, the export watcher and the bulk bar. `list.body.<resource>` is gone (P7-37).
+ *
+ * ⚠️ The `<PageHeader>` stays framework-owned. It is what writes `document.title` (via
+ * `useDocumentTitle`, defended against Next's metadata re-application) and what renders the
+ * page's accessible `<h1>` and its breadcrumb slot; the header's `h1` is `sr-only`.
  *
  * Both slots take no props and read the controller from
  * `useResourceListContext()`, so each is unit-testable against a
@@ -4035,7 +4369,13 @@ declare function ResourceListPage({ resource, meta, renderCell, emptyState }: Re
  * no `list.filters.<resource>` slot is registered, so this component itself
  * never has to know about the override ladder.
  */
-declare function FilterRegion(): React.ReactElement;
+declare function FilterRegion({ search }?: {
+  /**
+   * The search a placement declares (`related-list`'s `search` prop), `null` for none; the route
+   * list omits it and reads the resource's `views.list.search`.
+   */
+  readonly search?: SearchDecl | null;
+}): React.ReactElement;
 //#endregion
 //#region src/list-kit/filter-builder/filter-builder.d.ts
 type Expression$2 = FilterExpression<ErasedResourceHandle>;
@@ -4279,321 +4619,140 @@ interface PinnedFilterControlsProps {
  * `contains`) — is left completely alone: not read for display, not
  * overwritten, not removed. This is what stops a pinned control from
  * silently eating a call-site filter it does not own, or REWRITING one
- * it merely resembles — an earlier version of this rule matched on
- * `field` alone, so the first edit through a pinned control would adopt
- * and silently rewrite the operator of an expression it merely happened
- * to share a field with (SP2 final-review finding 4); the operator check
- * is what makes an unowned same-field expression fall through to
- * `FilterBadges`'s "nobody claimed this" badge instead.
- *
- * The operator used to read/write the owned expression is always
- * `spec.operators[0]` — the control renders no operator picker, so it has
- * no other operator to use even if some OTHER expression on the same field
- * happens to carry a different one.
- */
-declare function PinnedFilterControls(props: PinnedFilterControlsProps): React.ReactElement;
-//#endregion
-//#region src/list-kit/filter-builder/values/filter-value-control.d.ts
-interface FilterValueControlProps {
-  readonly kind: FilterKind;
-  readonly op: string;
-  readonly value: PortableValue | undefined;
-  readonly onChange: (value: PortableValue | undefined) => void;
-  /** `data-testid` prefix; inner parts append `:option:<v>`, `:search`, `:clear`. */
-  readonly testId: string;
-  /**
-   * The field's own label (`FilterFieldSpec.label`), threaded through so
-   * this control's accessible name can say WHICH field it is a value for —
-   * "Value for Status", not a bare "Value" indistinguishable from every
-   * other row's value control and, worse, from every OTHER pinned control
-   * in the toolbar (SP2 final-review finding 7). Optional and additive: a
-   * caller with no field label in hand (or a standalone/test mount) still
-   * gets the plain generic label every existing test asserts on.
-   */
-  readonly fieldLabel?: string;
-  readonly autoFocus?: boolean;
-  /**
-   * Delay (ms) before a scalar single-value edit (`ScalarValueInput`'s
-   * text/number/date box) commits upward. Only that control debounces —
-   * enum/relation/boolean commit on selection already, so they ignore this.
-   * Defaults to 300 (the legacy chip UX: don't spam the URL/provider on
-   * every keystroke). Pass `0` for a purely local draft — the filter-builder
-   * panel (`FilterPanel`) does, since its draft is in-memory React state,
-   * not a query param, so committing every keystroke is cheap and correct;
-   * a pinned control (`PinnedFilterControls`), which writes straight to the
-   * URL/provider, keeps the default.
-   */
-  readonly debounceMs?: number;
-  /**
-   * `FilterFieldSpec.options` (`@burojs/react`), threaded straight through
-   * from `FilterFieldRef.options` (`@burojs/core`). When present AND
-   * non-empty, THIS wins over the `kind`-derived dispatch below — a picker
-   * over exactly these value/label pairs, reusing `EnumValueControl`'s own
-   * popover (`SelectListValueControl`) rather than a free-text box,
-   * regardless of `kind`. `kind` itself is untouched by `options`: a plain
-   * `string` field with `options` still categorises (and renders its list
-   * column) as a `string`, never as `enum` — see `FilterFieldRef.options`'s
-   * own doc for why that distinction is the entire point.
-   *
-   * An EMPTY array falls through to the `kind`-derived dispatch exactly as
-   * `undefined` does — a picker with nothing to pick from is strictly worse
-   * than the field's ordinary control, not a valid (if degenerate) state.
-   */
-  readonly options?: readonly {
-    readonly value: string;
-    readonly label: string;
-  }[];
-  /**
-   * Stretch to the width of whatever contains this control, instead of the
-   * intrinsic width each kind picks for itself.
-   *
-   * The builder's rows (`FilterRow`) need it: their value column is one
-   * shared flex track, and a control that sizes itself leaves every row's
-   * remove button at a different x — which is exactly what made a panel with
-   * more than two rows look shattered. The pinned toolbar
-   * (`PinnedFilterControls`) must NOT have it: those controls sit inline
-   * among other toolbar items with no column to fill, and stretching them
-   * there would be the same bug with the roles reversed. So the width comes
-   * from the CALLER — the only place that knows whether there is a column —
-   * rather than from a blanket `w-full` on the controls themselves.
-   */
-  readonly fill?: boolean;
-}
-/**
- * The value half of a builder row.
- *
- * Arity comes from the OPERATOR, the input type from the FIELD — the two
- * are independent, which is why `in` on a string field is a chip list while
- * `contains` on the same field is a text box, and why `isNull` renders
- * nothing at all rather than a disabled input.
- *
- * Deliberately free of TanStack: these controls replace chips that read and
- * wrote through `column.getFilterValue()`, and that coupling is exactly what
- * kept them out of the relation picker (SP3).
- */
-declare function FilterValueControl(props: FilterValueControlProps): React.ReactElement | null;
-//#endregion
-//#region src/resource/resource-list.d.ts
-type RowRecord$1 = {
-  id: string;
-} & Record<string, unknown>;
-interface ResourceListProps {
-  resource: string;
-  data?: RowRecord$1[];
-  total?: number;
-  page?: number;
-  pageSize?: number;
-  /**
-   * Called when the user picks a different page size. The size selector is
-   * rendered ONLY when this is supplied — a list whose host does not persist
-   * page size should not offer a control that silently resets on navigation.
-   */
-  onPageSize?: (size: number) => void;
-  /**
-   * Ask the host for the row count of the CURRENTLY described set (Task
-   * B4.3). Rendered ONLY when this is supplied and `total` is unknown — the
-   * same "no control the host cannot honour" gate `onPageSize` above uses.
-   *
-   * This component is presentational by contract, so the trigger arrives as
-   * a prop rather than being read from `useResourceListContext()`:
-   * `useResourceListContext()` THROWS outside a provider
-   * (`list-kit/context.tsx`), and `<ResourceList>` must stay usable
-   * standalone — `SubresourceTabBody` mounts one with a hand-rolled count and
-   * no controller at all.
-   *
-   * ⚠️ Answering moves the user, on purpose. The host writes the answer into
-   * `total`, which flips `knownTotal` and with it four behaviours that are
-   * dead on an unknown-total list: `pagination.showing` replaces the
-   * range-only readout, the first/last jump buttons appear, `hasNextPage`
-   * switches from "this page is full" to `page < totalPages`, and the
-   * out-of-range clamp navigates a stale `?page=20` to the last real page.
-   * That last one is the point of offering the trigger on a wrong page at
-   * all.
-   */
-  onRequestCount?: () => void;
-  /**
-   * A count request is in flight. The trigger keeps its place and its width;
-   * only its label is swapped for a spinner, and it stops accepting clicks.
-   */
-  isCountingRows?: boolean;
-  /** Page-size choices. Defaults to a standard admin ladder. */
-  pageSizeOptions?: number[];
-  onPage?: (n: number) => void;
-  /**
-   * Opaque-token pagination. When supplied, the numbered pager is replaced by
-   * a load-more control: a token list has no page index to jump to. Absent →
-   * the offset pager renders exactly as before.
-   */
-  loadMore?: {
-    hasMore: boolean;
-    loading: boolean;
-    onMore: () => void;
-  };
-  selectable?: boolean;
-  /**
-   * Accumulating selection owned by the caller. When provided the component
-   * is CONTROLLED: this is the WHOLE selected set (ids that are not on the
-   * current page included), the component keeps no selection state of its
-   * own, and every change — including the page-scoped header checkbox — is
-   * reported through `onSelectionChange` as the new whole set.
-   *
-   * Omit it for the uncontrolled behaviour: the component owns the selection
-   * and drops it whenever `data` changes identity.
-   *
-   * ⚠️ A controlled caller MUST commit every emission it receives through
-   * `onSelectionChange` back into this prop: skip one and the `emittedRef`
-   * bridge (below) stays armed against a base the DOM never reflected, so
-   * the next toggle composes against a phantom selection instead of what's
-   * actually checked.
-   */
-  selectedIds?: string[];
-  onSelectionChange?: (ids: string[]) => void;
-  className?: string;
-  /** When true, show skeleton rows instead of the table. */
-  isLoading?: boolean;
-  /** When non-null, show an error state. */
-  error?: {
-    message: string;
-  } | Error | null;
-  /**
-   * Optional retry callback. When provided AND `error` is set, the
-   * error-state panel renders a "Retry" button that invokes this
-   * callback. The typical wiring is `onRetry={() => query.refetch()}`
-   * when the parent uses the framework's `useList` (or an equivalent
-   * `refetch()` method on the data source).
-   */
-  onRetry?: () => void;
-  /** Render an inline "+ Create" button in the empty state. */
-  createHref?: string;
-  /** Whether the list is currently filtered (changes empty-state copy). */
-  isFiltered?: boolean;
-  /** Called when the user clicks the "Clear filter" link in the filtered-empty state. */
-  onClearFilter?: () => void;
-  /**
-   * Replacement for the "no rows" rendering, forwarded to
-   * `<DataTable emptyState>`.
-   *
-   * ⚠️ This changes the SHAPE of the empty list, not just its copy. Left
-   * undefined (the default, and what every caller did before the slot work)
-   * this component early-returns a standalone panel INSTEAD of the table —
-   * dashed border, icon, heading, and one of three CTAs ("Clear filter" when
-   * filtered / "+ Create" when genuinely empty / "back to page 1" on an
-   * out-of-range page). Supplying a node skips that panel entirely: the
-   * table renders with its header row and the node fills a single body cell
-   * spanning every column, so the column headers survive but none of the
-   * CTAs do — the caller owns whatever recovery affordance the state needs.
-   *
-   * The footer/pagination is still hidden while there are no rows.
-   */
-  emptyState?: React.ReactNode;
-  /**
-   * If provided, each row becomes a clickable link to this href.
-   * Receives the row record; returns the navigation target.
-   * Default behavior: rows are not clickable. Set to `(row) => '/{resource}/{row.id}'`
-   * for typical show-page navigation.
-   */
-  rowHref?: (row: RowRecord$1) => string | undefined;
-  /**
-   * Per-cell custom renderer override. Returns `undefined` to fall back to
-   * the default field-type-based display. Use for badges, links, or any
-   * custom visual treatment that depends on column + value + row.
-   *
-   * MUST be a pure function of `(col, value, row)` — the cell it renders runs
-   * inside `<DataTable>`'s memoized row/cell (`MemoRow`/`MemoCell` in
-   * data-table.tsx), which intentionally skips re-rendering when a row's own
-   * data and selection state haven't changed. If the returned output depends
-   * on EXTERNAL reactive state (locale, a feature flag, anything read outside
-   * `col`/`value`/`row`), it will go stale under that memo the same way the
-   * built-in `DateDisplay`/`NumberDisplay` renderers did before they were
-   * fixed to self-subscribe to locale. Delegate any such state-dependent
-   * text to a component that subscribes to it itself (`useLocale()` /
-   * `useOptionalT()` — see `EnumDisplay`/`BooleanDisplay`/`DateDisplay` for
-   * the pattern) rather than resolving it inline in this callback.
-   */
-  renderCell?: (col: string, value: unknown, row: RowRecord$1) => React.ReactNode | undefined;
-  /** Current native sort expression. The header exposes the first sort key. */
-  sort?: readonly {
-    field: string;
-    direction: 'asc' | 'desc';
-  }[];
-  /**
-   * Sort request from a column header. `direction` is EXPLICIT when the header
-   * menu picks «по возрастанию/убыванию/сбросить» (`'asc'`/`'desc'`/`null`); it
-   * is omitted when a caller wants the legacy 3-click toggle. Consumers should
-   * honour an explicit direction and fall back to toggling when it's undefined.
-   */
-  onSort?: (field: string, direction?: 'asc' | 'desc' | null) => void;
+ * it merely resembles — an earlier version of this rule matched on
+ * `field` alone, so the first edit through a pinned control would adopt
+ * and silently rewrite the operator of an expression it merely happened
+ * to share a field with (SP2 final-review finding 4); the operator check
+ * is what makes an unowned same-field expression fall through to
+ * `FilterBadges`'s "nobody claimed this" badge instead.
+ *
+ * The operator used to read/write the owned expression is always
+ * `spec.operators[0]` — the control renders no operator picker, so it has
+ * no other operator to use even if some OTHER expression on the same field
+ * happens to carry a different one.
+ */
+declare function PinnedFilterControls(props: PinnedFilterControlsProps): React.ReactElement;
+//#endregion
+//#region src/list-kit/filter-builder/values/filter-value-control.d.ts
+interface FilterValueControlProps {
+  readonly kind: FilterKind;
+  readonly op: string;
+  readonly value: PortableValue | undefined;
+  readonly onChange: (value: PortableValue | undefined) => void;
+  /** `data-testid` prefix; inner parts append `:option:<v>`, `:search`, `:clear`. */
+  readonly testId: string;
   /**
-   * Hide a column from a column-header menu. Receives the column name; the
-   * parent removes it from the visible-columns list. When omitted, the header
-   * menu shows no «hide» item.
+   * The field's own label (`FilterFieldSpec.label`), threaded through so
+   * this control's accessible name can say WHICH field it is a value for —
+   * "Value for Status", not a bare "Value" indistinguishable from every
+   * other row's value control and, worse, from every OTHER pinned control
+   * in the toolbar (SP2 final-review finding 7). Optional and additive: a
+   * caller with no field label in hand (or a standalone/test mount) still
+   * gets the plain generic label every existing test asserts on.
    */
-  onHideColumn?: (field: string) => void;
+  readonly fieldLabel?: string;
   /**
-   * Columns that may NOT be hidden — the header menu omits «hide» for these.
-   * Without it every column is treated as hideable (when `onHideColumn` is set).
+   * Visible hint inside a text/number box (`ScalarValueInput`). Only a caller
+   * that shows the control with nothing naming its field beside it passes one:
+   * the pinned toolbar (`PinnedFilterControls`) gives the field's label, so a
+   * pinned text filter is not an unlabelled empty box (REF-44). A builder row
+   * names its field in its own field picker and passes none.
    */
-  requiredColumns?: string[];
+  readonly placeholder?: string;
+  readonly autoFocus?: boolean;
   /**
-   * Bump to reset the persisted column layout (#17). `resetLayout.mode`:
-   *   - `'sizes'` — clear user-resized widths only.
-   *   - `'all'`   — clear widths AND pinning AND order back to defaults.
-   * The token is what triggers it; increment it on each reset click.
+   * Delay (ms) before a scalar single-value edit (`ScalarValueInput`'s
+   * text/number/date box) commits upward. Only that control debounces —
+   * enum/relation/boolean commit on selection already, so they ignore this.
+   * Defaults to 300 (the legacy chip UX: don't spam the URL/provider on
+   * every keystroke). Pass `0` for a purely local draft — the filter-builder
+   * panel (`FilterPanel`) does, since its draft is in-memory React state,
+   * not a query param, so committing every keystroke is cheap and correct;
+   * a pinned control (`PinnedFilterControls`), which writes straight to the
+   * URL/provider, keeps the default.
    */
-  resetLayout?: {
-    token: number;
-    mode: 'sizes' | 'all';
-  };
+  readonly debounceMs?: number;
   /**
-   * Override for the column list rendered in the table. When omitted,
-   * the table falls back to `def.views.list.columns` (or all field
-   * keys). When provided, the table renders EXACTLY this set in the
-   * given order — useful for the user-toggleable Columns menu (see
-   * `views.list.optionalColumns` / `requiredColumns`).
+   * `FilterFieldSpec.options` (`@burojs/react`), threaded straight through
+   * from `FilterFieldRef.options` (`@burojs/core`). When present AND
+   * non-empty, THIS wins over the `kind`-derived dispatch below — a picker
+   * over exactly these value/label pairs, reusing `EnumValueControl`'s own
+   * popover (`SelectListValueControl`) rather than a free-text box,
+   * regardless of `kind`. `kind` itself is untouched by `options`: a plain
+   * `string` field with `options` still categorises (and renders its list
+   * column) as a `string`, never as `enum` — see `FilterFieldRef.options`'s
+   * own doc for why that distinction is the entire point.
+   *
+   * An EMPTY array falls through to the `kind`-derived dispatch exactly as
+   * `undefined` does — a picker with nothing to pick from is strictly worse
+   * than the field's ordinary control, not a valid (if degenerate) state.
    */
-  columns?: string[];
+  readonly options?: readonly {
+    readonly value: string;
+    readonly label: string;
+  }[];
   /**
-   * Optional callback that hands the parent the underlying TanStack
-   * `Table` instance. Fires once after the table is mounted (and
-   * again with `null` on unmount). Use this when the parent needs to
-   * read selection state for components that live OUTSIDE the table
-   * (e.g. `<BulkActionToolbar>` which calls
-   * `table.getFilteredSelectedRowModel().rows`). The id-array
-   * `onSelectionChange` callback remains the recommended way to
-   * trigger a parent re-render on selection changes — `tableRef`
-   * gives access to the rows, not a re-render signal.
+   * Stretch to the width of whatever contains this control, instead of the
+   * intrinsic width each kind picks for itself.
+   *
+   * The builder's rows (`FilterRow`) need it: their value column is one
+   * shared flex track, and a control that sizes itself leaves every row's
+   * remove button at a different x — which is exactly what made a panel with
+   * more than two rows look shattered. The pinned toolbar
+   * (`PinnedFilterControls`) must NOT have it: those controls sit inline
+   * among other toolbar items with no column to fill, and stretching them
+   * there would be the same bug with the roles reversed. So the width comes
+   * from the CALLER — the only place that knows whether there is a column —
+   * rather than from a blanket `w-full` on the controls themselves.
    */
-  tableRef?: (table: Table$1<RowRecord$1> | null) => void;
+  readonly fill?: boolean;
 }
-declare function ResourceList({ resource, data, total, page, pageSize, onPageSize, onRequestCount, isCountingRows, pageSizeOptions, onPage, loadMore, selectable, selectedIds, onSelectionChange, className, isLoading, error, onRetry, createHref, isFiltered, onClearFilter, emptyState, rowHref, renderCell, sort, onSort, onHideColumn, requiredColumns, resetLayout, columns: columnsOverride, tableRef }: ResourceListProps): React.ReactElement;
+/**
+ * The value half of a builder row.
+ *
+ * Arity comes from the OPERATOR, the input type from the FIELD — the two
+ * are independent, which is why `in` on a string field is a chip list while
+ * `contains` on the same field is a text box, and why `isNull` renders
+ * nothing at all rather than a disabled input.
+ *
+ * Deliberately free of TanStack: these controls replace chips that read and
+ * wrote through `column.getFilterValue()`, and that coupling is exactly what
+ * kept them out of the relation picker (SP3).
+ */
+declare function FilterValueControl(props: FilterValueControlProps): React.ReactElement | null;
 //#endregion
 //#region src/list-kit/list-slots.d.ts
 /**
- * The three override seams `<ResourceListPage>` opens on the standard list
- * (core flexibility program, Task B3.2; level 1 added by SP0 Task 5) — the
- * "level 1", "level 2" and "level 3" rungs of the spec's override ladder:
+ * The two override seams `<ResourceListPage>` opens on the standard list (core flexibility
+ * program, Task B3.2; level 1 added by SP0 Task 5) — the "level 1" and "level 2" rungs of the
+ * spec's override ladder:
  *
  * ```
  * level 0  nothing registered   → the standard assembled list
  * level 1  list.cell.<r>        → one column's renderer; everything else stays standard
  * level 2  list.filters.<r>     → custom filter region; table/footer stay standard
- * level 3  list.body.<r>        → the whole body is yours
  * ```
  *
+ * ⚠️ **The old level 3, `list.body.<r>`, is gone (P7-37).** A whole-body override is a list frame
+ * (`views.list.frame`, `defineFrame(id, { for: 'list' })`): it places the framework's pieces
+ * (`<ListControls/>`, `<ListBody/>`, …) instead of replacing them, so it keeps the filters, the
+ * saved views, the columns menu, URL state, selection and the bulk bar. A component still
+ * registered under `list.body.<r>` is a development error at mount and a `checkApp` error
+ * (`list.body-removed`), never a silent no-op.
+ *
  * ⚠️ **Level 1 is reachable through the registry now, not only through a
  * prop.** `<ResourceList renderCell>` / `<ResourceListPage renderCell>` still
  * work — an explicit prop wins over the registered slot — but neither is
  * reachable through the standard `NavAreaPage` router, which mounts
  * `<ResourceListPage resource={...} />` with no props at all. Before this,
  * an adopter who wanted one column rendered as a badge had no way to reach
- * that router and had to register `list.body.<r>` instead, trading away
+ * that router and had to replace the whole list body instead, trading away
  * filters, the columns menu, saved views and URL state to repaint a single
- * cell. `list.cell.<r>` closes that gap the same way `list.filters.<r>` and
- * `list.body.<r>` already do.
+ * cell. `list.cell.<r>` closes that gap the same way `list.filters.<r>` does.
  *
  * ⚠️ **`list.cell.<r>` never sees a column `<ResourceListPage>`'s OWN
  * built-in branches already claimed.** A column with a declared `enum`
- * gets the framework's `<EnumBadge>`, and a template-discriminator column
+ * gets the framework's `<EnumBadge>`, and a typed resource's discriminator column
  * gets its label/badge, BEFORE either the `renderCell` prop or the
  * `list.cell.<r>` slot is consulted — same as the pre-Task-5 behaviour for
  * the prop. The registered renderer's function is simply never called for
@@ -4601,20 +4760,20 @@ declare function ResourceList({ resource, data, total, page, pageSize, onPageSiz
  * This is the genuinely surprising half of the contract, so it is
  * exercised explicitly in `tests/list-cell-slot.test.tsx`.
  *
- * ⚠️ **Polling is no longer a reason to drop to level 3.** A list that needs
+ * ⚠️ **Polling is no longer a reason to write a list frame.** A list that needs
  * fresh data declares `views.list.refetchInterval` (`@burojs/core`); the
  * controller resolves it into a `live` slice and `<ResourceListPage>` renders
- * the pause toggle. Every adopter surface that reached for `list.body.<r>`
- * *only* to get a `refetchInterval` gave up filters, the columns menu, saved
- * views and URL state to buy one option it can now declare.
+ * the pause toggle. Every adopter surface that replaced the body *only* to get a
+ * `refetchInterval` gave up filters, the columns menu, saved views and URL state to buy one
+ * option it can now declare.
  *
  * ⚠️ **Slots are registered through the Components registry, NOT on
  * `ResourceConfig`.** `packages/core` declares `dependencies: {}` and
  * imports React nowhere, and `ResourceViews` is non-generic — an inline
  * `ComponentType` on the config would both drag React into core and lose
- * `TRecord` inference. The registry is the existing namespaced convention
- * (`show.banner.<resource>`, `tab.<key>`, `page:<name>`, `layout:<key>`),
- * and it needs zero core changes.
+ * `TRecord` inference. The registry's keys are dotted with the canonical
+ * resource last (`list.<region>.<resource>`, `record.<action>.<resource>`,
+ * `layout.<key>`), and they need zero core changes.
  *
  * @see docs/specs/core-flexibility-overview.md §3
  * @see docs/superpowers/plans/2026-07-26-cfb3-assembled-page-slots.md — Task B3.2
@@ -4628,10 +4787,8 @@ declare function ResourceList({ resource, data, total, page, pageSize, onPageSiz
  * - `'filters'` — the filter region only (search box + dynamic filter chips
  *   + "+ Add filter"). Saved views, the columns toggle, the create button,
  *   the table, the footer and pagination all stay standard.
- * - `'body'` — everything below the page header: the whole toolbar row, the
- *   saved-view dialogs, the table, the footer and the bulk bar.
  */
-type ListSlotRegion = 'filters' | 'body' | 'cell';
+type ListSlotRegion = 'filters' | 'cell';
 /**
  * A list slot component. It takes **no props**: everything it needs — rows,
  * query state, filters, sorting, columns, selection, saved views, hrefs —
@@ -4666,12 +4823,12 @@ type ListCellRenderer = NonNullable<ResourceListProps['renderCell']>;
  * <BuroProvider components={{ [listSlot('filters', 'code_code')]: CodeFilterRegion }}>
  * ```
  *
- * ⚠️ The signature takes `(region, resource)` rather than the single
- * `listSlot(name)` the plan sketched: the key this has to produce is
- * `list.<region>.<resource>` (the `show.banner.<resource>` precedent), and
- * one argument cannot carry both halves. Typing `region` as a union rather
- * than a free string is the point of the helper — a typo'd slot key is
- * otherwise a silent no-op, which is precisely how registry slots fail.
+ * The key is `list.<region>.<resource>` with the resource canonicalised, as
+ * `canonicalResourceName` does: the bare id in the default namespace (`order` and
+ * `default:order` name the same slot), `namespace:id` otherwise
+ * (`list.cell.crm:deals`). Typing `region` as a union rather than a free
+ * string is the point of the helper — a typo'd slot key is otherwise a
+ * silent no-op, which is precisely how registry slots fail.
  */
 declare function listSlot(region: ListSlotRegion, resource: string): string;
 /**
@@ -4686,11 +4843,11 @@ declare function listSlot(region: ListSlotRegion, resource: string): string;
  * call directly. A single widened return type would let `useListSlot('cell',
  * r)`'s result typecheck as `<Slot />`, which compiles and then explodes at
  * render (a component invoked as a 3-arg function, or vice versa). The
- * `'filters' | 'body'` overload's contract is byte-identical to before this
+ * `'filters'` overload's contract is byte-identical to before this
  * region existed.
  */
 declare function useListSlot(region: 'cell', resource: string): ListCellRenderer | undefined;
-declare function useListSlot(region: 'filters' | 'body', resource: string): ListSlot | undefined;
+declare function useListSlot(region: 'filters', resource: string): ListSlot | undefined;
 //#endregion
 //#region src/saved-views/saved-views-dropdown.d.ts
 /**
@@ -4781,378 +4938,67 @@ interface SavedViewsDropdownProps {
    *   'fork-entry'      → an entry's inline Fork button (viewId passed)
    *   'issues-notice'   → the adapter-issues banner (no viewId)
    */
-  getTestId?: (role: 'trigger' | 'menu' | 'view-item' | 'save-current' | 'manage' | 'separator' | 'section-header' | 'rename-entry' | 'delete-entry' | 'fork-entry' | 'issues-notice', viewId?: string) => string | undefined;
-  /** Trigger label override. Default: "Views". */
-  triggerLabel?: string;
-  /**
-   * Render the trigger as a compact icon-only square button (no visible label).
-   * `triggerLabel` becomes the `aria-label` + tooltip. The bookmark icon (the
-   * saved-views affordance) stays.
-   */
-  iconOnly?: boolean;
-  /** className applied to the trigger button. */
-  triggerClassName?: string;
-  /** className applied to the popover content. */
-  popoverContentClassName?: string;
-  /** Popover content alignment. Default: 'start'. */
-  popoverAlign?: 'start' | 'center' | 'end';
-}
-declare function SavedViewsDropdown({ adopterViews, entries, issues, onApply, onSaveCurrent, canSaveCurrent, onManage, onRenameEntry, onDeleteEntry, onForkEntry, canFork, getTestId, triggerLabel, iconOnly, triggerClassName, popoverContentClassName, popoverAlign }: SavedViewsDropdownProps): React.ReactElement;
-//#endregion
-//#region src/resource/list-error-state.d.ts
-interface ListErrorStateProps {
-  /** Whatever the query threw. */
-  error: {
-    message?: string;
-  } | Error;
-  /** When provided, a Retry button is rendered and calls this. */
-  onRetry?: () => void;
-  /** Resource name, used to build the retry button's test id. */
-  resource?: string;
-  /** Overrides the default «Не удалось загрузить данные» heading. */
-  title?: string;
-  className?: string;
-}
-/**
- * The canonical "this list failed to load" panel: icon, heading, an
- * actionable sentence, and a Retry button.
- *
- * ⚠️ Extracted from `<ResourceList>` because it was trapped inside it. The
- * `schedules` list is rendered by a level-3 body slot, which is the whole
- * point of slots — but the slot then had to hand-roll its own error branch,
- * and hand-rolled it worse: a bare red card printing
- *
- *   «Не удалось загрузить расписания. Temporal GET
- *    /namespaces/default/schedules?maximumPageSize=10 -> 502»
- *
- * — a raw internal HTTP trace under a Russian sentence, with NO way to retry.
- * When Temporal was briefly down, the only recovery was reloading the page.
- *
- * A slot author should not have to re-derive an error state the framework
- * already knows how to render, so this is now shared by both. `toFriendlyError`
- * keeps the technical string out of the operator's face while leaving
- * adopter-written messages verbatim; the raw text stays reachable under
- * «Подробности» for whoever has to file the bug.
- */
-declare function ListErrorState({ error, onRetry, resource, title, className }: ListErrorStateProps): React.ReactElement;
-//#endregion
-//#region src/resource/resource-show.d.ts
-interface ResourceShowProps {
-  resource: string;
-  record: {
-    id: string;
-  } & Record<string, unknown>;
-  className?: string;
-  /**
-   * Slot for adopter-supplied UI rendered to the RIGHT of the resolved
-   * `<ActionOverflow surface="show">` — NOT an action itself, just arbitrary
-   * chrome the host wants next to the toolbar (a status badge, a link out to
-   * another system, anything that isn't dispatched through the action
-   * registry). Every entity already carries the built-in Edit and Delete
-   * (plus any registry-declared actions whose surface includes `'show'`)
-   * through `<ActionOverflow>`, so this slot no longer needs to (and must
-   * not try to) supply page-local Edit/Delete of its own — there is nothing
-   * left for it to fill in there. It renders directly alongside the
-   * registry actions with no separator between them; the two are one visual
-   * group, not two.
-   */
-  extraActions?: ReactNode;
-  /**
-   * When true, ResourceShow renders WITHOUT its own `<PageHeader>` (no
-   * breadcrumb / title / toolbar actions) — only the banner + field card,
-   * still wrapped in the `page-show` testid root.
-   *
-   * Used by the tabbed detail shell (`ResourceShowTabs`), which hoists a
-   * SINGLE header above the tab strip so item actions stay visible on every
-   * tab. The non-tabbed page leaves this false and renders its own header.
-   */
-  hideHeader?: boolean;
-  /**
-   * Optional breadcrumb override rendered in the page header IN PLACE OF the
-   * default `<Breadcrumbs resource pageLabel>`. Pass a custom `<Breadcrumbs>`
-   * (e.g. with `leadingSegments` + a different root `resource`) to root the
-   * detail page at a different list — the sub-project-5 "sticky nav" uses this
-   * so a document opened from a per-type list breadcrumbs back to that list +
-   * section instead of the generic Documents list. Undefined → default.
-   */
-  breadcrumbs?: ReactNode;
-  /**
-   * Optional per-context field map MERGED over the resource-level `def.fields`
-   * — same contract as `ResourceForm`'s prop of the same name (override keys
-   * win on collision, resource-only keys still render). Omitted → the details
-   * panel renders `def.fields`, or the matched document type's field set when
-   * this resource declares `templates`.
-   *
-   * ⚠️ Not the document-type mechanism: a templated resource resolves its own
-   * projection from `record[templates.discriminatorField]`, replacing rather
-   * than merging. Passing this prop turns that resolution OFF for this render.
-   */
-  fieldsOverride?: ResourceFieldMap;
-  /**
-   * Optional layout override — same contract as `ResourceForm`'s prop of the
-   * same name: when set, it REPLACES `views.show.fields ?? views.fields`
-   * outright for this render.
-   *
-   * Precedence: this prop → the matched template's `views.fields` → the
-   * resource's own.
-   */
-  fieldsLayoutOverride?: FieldLayoutSpec;
-}
-/**
- * Resolve a record's display name using the resource's `displayField`,
- * falling back to `id`.
- */
-declare function recordDisplayName(record: Record<string, unknown>, displayField?: string): string;
-/**
- * Per-resource banner slot. Rendered above the field card when the adopter
- * registers a component under `show.banner.<resource>` in the global components
- * map (see `mergeComponents` + `<BuroProvider components={...}>`).
- *
- * Resources that do NOT register an override get the default render — the
- * 22 prior e2e specs verify this backward-compat path.
- */
-interface ResourceShowBannerProps {
-  resource: string;
-  record: {
-    id: string;
-  } & Record<string, unknown>;
-}
-/**
- * The show-page `<PageHeader>` (breadcrumb + title + the resolved
- * `<ActionOverflow surface="show">` item-action list, then any adopter
- * `extraActions`).
- *
- * Extracted so BOTH the non-tabbed `<ResourceShow>` (which renders it inline)
- * and the tabbed shell (`ResourceShowTabs`, which hoists it above the tab
- * strip so it stays visible on every tab) render the identical header from one
- * source of truth.
- */
-declare function ShowPageHeader({ resource, record, extraActions, breadcrumbs }: {
-  resource: string;
-  record: {
-    id: string;
-  } & Record<string, unknown>;
-  extraActions?: ReactNode;
-  breadcrumbs?: ReactNode;
-}): React.ReactElement | null;
-declare function ResourceShow({ resource, record, className, extraActions, hideHeader, fieldsOverride, fieldsLayoutOverride, breadcrumbs }: ResourceShowProps): React.ReactElement | null;
-//#endregion
-//#region src/resource/detail-tabs-shell.d.ts
-interface DetailTabsShellProps {
-  resource: string;
-  record: {
-    id: string;
-  } & Record<string, unknown>;
-  /** Which detail surface this shell serves — drives `resolveTabs(view)`. */
-  view: TabView;
-  /**
-   * The currently active tab key. Resolved against the VISIBLE tab set (see
-   * `resolveTabs`): an unknown / hidden value falls back to the `details` tab
-   * when present, else the first visible tab. Pass `undefined` to default to
-   * `details`.
-   */
-  activeTab?: string;
-  /**
-   * Called when the user clicks a tab trigger. Receives the new tab key
-   * (`details` for the field/form panel, otherwise the tab's `key`).
-   * Consumers typically wire this to a URL search-param so deep-links /
-   * back-forward navigation work. When omitted, the shell falls back to
-   * internal state (uncontrolled).
-   */
-  onTabChange?: (tab: string) => void;
-  /**
-   * Optional renderer for relation-tab list rows. Forwarded to the embedded
-   * `<ResourceList>`'s `rowHref`. Default behaviour produces
-   * `/{childResource}/{row.id}` so a row click navigates to the standalone
-   * show page.
-   */
-  subresourceRowHref?: (childResource: string, row: {
-    id: string;
-  }) => string;
-  /**
-   * The SINGLE page header, rendered ABOVE the tab strip and therefore always
-   * visible regardless of the active tab. Item toolbar actions live here so
-   * they never vanish when a non-details tab is active. Only mounted on the
-   * tabbed path (the fast path uses `renderStandalone`'s own header).
-   */
-  header: ReactNode;
-  /**
-   * Renders the `details` tab body WITHOUT its own header (chromeless): the
-   * Show field card for `view: 'show'`, or the Edit form for `view: 'edit'`.
-   */
-  renderDetails: () => ReactNode;
-  /**
-   * Renders the standalone page (WITH its own header) used on the fast path —
-   * when the resource resolves to only the synthesized `details` tab. Keeps
-   * the no-tabs page byte-identical to the pre-tabs component.
-   */
-  renderStandalone: () => ReactNode;
-}
-/**
- * Shared detail-page tab shell for Show AND Edit.
- *
- * Fast path: when `resolveTabs` yields only the synthesized `details` tab (the
- * resource declares no tabs for this view and has no subresources), the shell
- * is a transparent passthrough to `renderStandalone()` — no Tabs primitive in
- * the tree, no visual change, and the standalone component renders its own
- * header exactly as before.
- *
- * Tabbed path: a single hoisted `header` renders above the `TabsList` (always
- * visible), the `details` tab hosts the chromeless content from
- * `renderDetails()`, and component / relation tabs render lazily (Radix
- * unmounts inactive `Tabs.Content`, so an inactive tab's `useList` / fetch
- * never fires until it is activated).
- */
-declare function DetailTabsShell(props: DetailTabsShellProps): React.ReactElement | null;
-interface SubresourceTabBodyProps {
-  childResource: string;
-  foreignKey: string;
-  parentId: string;
-  rowHref: (row: {
-    id: string;
-  } & Record<string, unknown>) => string;
-  /**
-   * Rows per page. Default `10` — the value this component hardcoded before
-   * the knob existed, so omitting it changes nothing.
-   *
-   * Excluded from the count key on purpose: see the `countKey` note below.
-   */
-  pageSize?: number;
-  /**
-   * Extra filters **ANDed with** the parent FK filter.
-   *
-   * ⚠️ They never REPLACE it. The FK is what makes this list a sub-resource of
-   * the open record; a filter array that supplanted it would silently turn a
-   * tab that reads as "this document's codes" into a listing of every row in
-   * the child table.
-   */
-  filters?: readonly FilterExpression<ErasedResourceHandle>[];
-  /**
-   * Field a free-text search box targets. **Absent → no box is rendered**, the
-   * same rule `views.list.search` follows on the standalone list page. A bare
-   * field name, NOT a `SearchDecl` — this is TAB level, one field, no
-   * resolver escape hatch. The term is composed via `searchToFilter` as
-   * `{ field: search, op: 'contains' }` and ANDed onto the filters above.
-   */
-  search?: string;
-}
-/**
- * Mounts a paginated `<ResourceList>` of `childResource` filtered to
- * `foreignKey === parentId`. Same internals as the standalone list page; the
- * FK filter is non-clearable from inside the tab (the user is in the parent's
- * context — clearing it would surface unrelated rows).
- *
- * Three optional knobs tune the surface — `pageSize`, `filters`, `search`
- * (Task B6.1, closing this component's own `TODO(v2)`). Every one of them is
- * absent by default, and absent means the pre-B6 behaviour to the byte: ten
- * rows a page, no search box, the FK as the only filter. Adopters normally
- * declare them on the tab (`RelationTab`) rather than here; they exist as
- * props because this component is exported for bespoke tab layouts.
- *
- * `sort` is deliberately NOT among them. The embedded list renders a fixed
- * column set with no sort affordance, so a declaration site with no reader
- * would be exactly the dead `views.list.filters` key the program is deleting.
- *
- * Exported so adopters composing bespoke tab layouts can reuse the embedded
- * filtered list without re-implementing the `useList` + FK-filter wiring.
- */
-declare function SubresourceTabBody({ childResource, foreignKey, parentId, rowHref, pageSize, filters: extraFilters, search: searchField }: SubresourceTabBodyProps): ReactNode;
-//#endregion
-//#region src/resource/resource-show-tabs.d.ts
-interface ResourceShowTabsProps extends ResourceShowProps {
-  /**
-   * The currently active tab key. Resolved against the VISIBLE tab set (see
-   * `resolveTabs`): an unknown / hidden value falls back to the `details` tab
-   * when present, else the first visible tab. Pass `undefined` to default to
-   * `details`.
-   */
-  activeTab?: string;
-  /**
-   * Called when the user clicks a tab trigger. Receives the new tab key
-   * (`details` for the field panel, otherwise the tab's `key` — a subresource
-   * name for auto-relation tabs). Consumers typically wire this to a URL
-   * search-param via the router so deep-links / back-forward navigation work.
-   * When omitted, the component falls back to internal state (uncontrolled).
-   */
-  onTabChange?: (tab: string) => void;
+  getTestId?: (role: 'trigger' | 'menu' | 'view-item' | 'save-current' | 'manage' | 'separator' | 'section-header' | 'rename-entry' | 'delete-entry' | 'fork-entry' | 'issues-notice', viewId?: string) => string | undefined;
+  /** Trigger label override. Default: "Views". */
+  triggerLabel?: string;
   /**
-   * Optional renderer for relation-tab list rows. Forwarded to the embedded
-   * `<ResourceList>`'s `rowHref`. Default behaviour produces
-   * `/{childResource}/{row.id}` so a row click navigates to the standalone
-   * show page (the "shows in tab AND has standalone pages" contract).
+   * Render the trigger as a compact icon-only square button (no visible label).
+   * `triggerLabel` becomes the `aria-label` + tooltip. The bookmark icon (the
+   * saved-views affordance) stays.
    */
-  subresourceRowHref?: (childResource: string, row: {
-    id: string;
-  }) => string;
+  iconOnly?: boolean;
+  /** className applied to the trigger button. */
+  triggerClassName?: string;
+  /** className applied to the popover content. */
+  popoverContentClassName?: string;
+  /** Popover content alignment. Default: 'start'. */
+  popoverAlign?: 'start' | 'center' | 'end';
 }
-/**
- * Renders `<ResourceShow>` with a declarative tab strip resolved by the core
- * `resolveTabs` helper — Details (the field panel) + any `component` /
- * `relation` tabs declared on the resource / template, plus auto-generated
- * relation tabs for every registered subresource.
- *
- * The page header (breadcrumb + the resolved `<ActionOverflow surface="show">`
- * item-action list, then adopter `extraActions`) is hoisted ABOVE the tab strip by the
- * shared `DetailTabsShell`, so item actions stay visible on every tab. The
- * `details` tab therefore renders `<ResourceShow>` chromeless (`hideHeader`).
- *
- * Fast path: when the resource declares no `tabs`, has no subresources, and
- * `resolveTabs` yields only the synthesized `details` tab, this is a
- * transparent passthrough to a plain `<ResourceShow>` (own header, no Tabs
- * primitive in the tree, no visual change).
- */
-declare function ResourceShowTabs(props: ResourceShowTabsProps): React.ReactElement | null;
+declare function SavedViewsDropdown({ adopterViews, entries, issues, onApply, onSaveCurrent, canSaveCurrent, onManage, onRenameEntry, onDeleteEntry, onForkEntry, canFork, getTestId, triggerLabel, iconOnly, triggerClassName, popoverContentClassName, popoverAlign }: SavedViewsDropdownProps): React.ReactElement;
 //#endregion
-//#region src/resource/tab-body.d.ts
-/**
- * Props injected into every `component` tab body. The framework passes the
- * host `resource` name and the loaded `record` so the adopter's component can
- * fetch / render record-scoped content without re-reading the route.
- */
-interface TabComponentProps {
-  resource: string;
-  record: {
-    id: string;
-  } & Record<string, unknown>;
-}
-interface TabBodyProps {
-  /**
-   * Resolved component for this tab's slot — looked up via
-   * `useComponent('tab.<key>')` by the caller. `undefined` when the slot is
-   * unregistered; `<TabBody>` then renders a graceful empty state instead of
-   * crashing the page.
-   */
-  component?: ComponentType<TabComponentProps>;
-  resource: string;
-  record: {
-    id: string;
-  } & Record<string, unknown>;
-}
-interface TabBodyState {
-  error: Error | null;
+//#region src/resource/list-error-state.d.ts
+interface ListErrorStateProps {
+  /** Whatever the query threw. */
+  error: {
+    message?: string;
+  } | Error;
+  /** When provided, a Retry button is rendered and calls this. */
+  onRetry?: () => void;
+  /** Resource name, used to build the retry button's test id. */
+  resource?: string;
+  /** Overrides the default «Не удалось загрузить данные» heading. */
+  title?: string;
+  className?: string;
 }
 /**
- * Framework wrapper for a declarative `component` tab body.
+ * The canonical "this list failed to load" panel: icon, heading, an
+ * actionable sentence, and a Retry button.
  *
- * Three responsibilities, all containment:
+ * ⚠️ Extracted from `<ResourceList>` because it was trapped inside it. The
+ * `schedules` list is rendered by a level-3 body slot, which is the whole
+ * point of slots — but the slot then had to hand-roll its own error branch,
+ * and hand-rolled it worse: a bare red card printing
  *
- *  - **ErrorBoundary** (this class): a throwing tab body must NOT take down the
- *    whole show page. There is no other error boundary in the resource render
- *    tree, so this is the containment point — a crash renders a small inline
- *    error state and the rest of the page (header, other tabs) stays alive.
- *  - **Suspense**: the child may lazy-import or suspend on data; a skeleton
- *    shows until it resolves. Radix `Tabs.Content` unmounts inactive tabs, so a
- *    lazy body's `useList` / fetch never fires until its tab is activated.
- *  - **Empty state**: when the slot is unregistered (`component` is undefined)
- *    the wrapper renders a muted placeholder rather than throwing.
+ *   «Не удалось загрузить расписания. Temporal GET
+ *    /namespaces/default/schedules?maximumPageSize=10 -> 502»
+ *
+ * — a raw internal HTTP trace under a Russian sentence, with NO way to retry.
+ * When Temporal was briefly down, the only recovery was reloading the page.
  *
- * Deliberately minimal — no retry / reset UI in v1.
+ * A slot author should not have to re-derive an error state the framework
+ * already knows how to render, so this is now shared by both. `toFriendlyError`
+ * keeps the technical string out of the operator's face while leaving
+ * adopter-written messages verbatim; the raw text stays reachable under
+ * «Подробности» for whoever has to file the bug.
  */
-declare class TabBody extends Component$1<TabBodyProps, TabBodyState> {
-  state: TabBodyState;
-  static getDerivedStateFromError(error: unknown): TabBodyState;
-  render(): ReactNode;
-}
+declare function ListErrorState({ error, onRetry, resource, title, className }: ListErrorStateProps): React.ReactElement;
+//#endregion
+//#region src/resource/record-display-name.d.ts
+/**
+ * A record's display name: its `displayField` value when present and non-empty, else its `id`.
+ * Exported for consumers building delete dialogs, breadcrumbs and relation labels.
+ */
+declare function recordDisplayName(record: Record<string, unknown>, displayField?: string): string;
 //#endregion
 //#region src/resource/page-header.d.ts
 interface PageHeaderProps {
@@ -5160,10 +5006,10 @@ interface PageHeaderProps {
   resource: string;
   /**
    * Page mode. Drives default title:
-   *  - 'list'   → label.plural
-   *  - 'show'   → label.single + ': ' + recordName
-   *  - 'edit'   → 'Edit ' + label.single + ': ' + recordName
-   *  - 'create' → 'Create ' + label.single
+   *  - 'list'   → labelPlural
+   *  - 'show'   → label + ': ' + recordName
+   *  - 'edit'   → 'Edit ' + label + ': ' + recordName
+   *  - 'create' → 'Create ' + label
    */
   mode: 'list' | 'show' | 'edit' | 'create';
   /** Display name of the current record (for show/edit). */
@@ -5173,7 +5019,7 @@ interface PageHeaderProps {
    * (or `/{resource}` fallback) for show/edit/create.
    */
   backHref?: string;
-  /** Override the back-link label. Defaults to label.plural. */
+  /** Override the back-link label. Defaults to labelPlural. */
   backLabel?: string;
   /** Slot for action buttons (Edit/Delete/+Create) on the right. */
   actions?: ReactNode;
@@ -5184,7 +5030,7 @@ interface PageHeaderProps {
    * the back-link is suppressed in favour of the breadcrumb (the two
    * are functionally redundant — a breadcrumb's leading link points
    * at the same URL as the back-link, with more spatial context).
-   * Pass `<Breadcrumbs pageLabel={recordName} />` from
+   * Pass `<Breadcrumbs resource={resource} pageLabel={recordName} />` from
    * `@burojs/ui-shadcn` for the canonical resource-rooted layout.
    */
   breadcrumbs?: ReactNode;
@@ -5223,239 +5069,43 @@ interface PageHeaderProps {
   className?: string;
 }
 declare function PageHeader({ resource, mode, recordName, backHref, backLabel, actions, title, breadcrumbs, backLink, visibleTitle, labelOverride, className }: PageHeaderProps): React.ReactElement | null;
-//#endregion
-//#region src/resource/resource-edit.d.ts
-interface ResourceEditProps {
+/**
+ * The show-page `<PageHeader>`: the breadcrumb, the record's title and the resolved
+ * `<ActionOverflow surface="show">` item-action list, then any `extraActions`.
+ */
+declare function ShowPageHeader({ resource, record, extraActions, breadcrumbs }: {
   resource: string;
   record: {
     id: string;
   } & Record<string, unknown>;
-  onSave: (values: Record<string, unknown>) => Promise<void>;
-  onCancel?: () => void;
-  className?: string;
-  /** Override the back-link href (defaults to the show page for this record). */
-  backHref?: string;
-  /**
-   * Optional per-template field map. Forwarded to ResourceForm; keys override
-   * the resource-level `def.fields` on collision. Used by the document-
-   * templates v1 wiring on the playground edit page.
-   */
-  fieldsOverride?: ResourceFieldMap;
-  /**
-   * Optional per-template layout override forwarded to ResourceForm. See
-   * `ResourceFormProps.fieldsLayoutOverride` — pass the matched template's
-   * `views?.fields` alongside `fieldsOverride`.
-   */
-  fieldsLayoutOverride?: FieldLayoutSpec;
-  /**
-   * Optional derived-value map forwarded to ResourceForm. See
-   * `ResourceFormProps.derive`. On edit, a target that already holds a saved
-   * value is never auto-overwritten.
-   */
-  derive?: Record<string, (values: Record<string, unknown>) => unknown>;
-  /**
-   * When true, ResourceEdit renders WITHOUT its own `<PageHeader>` — only the
-   * form, still wrapped in the `page-edit` testid root.
-   *
-   * Used by the tabbed detail shell (`ResourceEditTabs`), which hoists a
-   * SINGLE header above the tab strip so edit-surface item actions stay
-   * visible on every tab. The non-tabbed page leaves this false.
-   */
-  hideHeader?: boolean;
-}
+  extraActions?: ReactNode;
+  breadcrumbs?: ReactNode;
+}): React.ReactElement | null;
 /**
- * The edit-page `<PageHeader>` (back-link + title + the resolved
- * `<ActionOverflow surface="edit">` item-action list).
- *
- * Extracted so BOTH the non-tabbed `<ResourceEdit>` (which renders it inline)
- * and the tabbed shell (`ResourceEditTabs`, which hoists it above the tab
- * strip) render the identical header from one source of truth.
+ * The edit-page `<PageHeader>`: the back-link, the record's title and the resolved
+ * `<ActionOverflow surface="edit">` item-action list.
  */
-declare function EditPageHeader({ resource, record, backHref }: {
+declare function EditPageHeader({ resource, record, backHref, breadcrumbs }: {
   resource: string;
   record: {
     id: string;
   } & Record<string, unknown>;
   backHref?: string;
+  breadcrumbs?: ReactNode;
 }): React.ReactElement;
-declare function ResourceEdit({ resource, record, onSave, onCancel, className, backHref, fieldsOverride, fieldsLayoutOverride, derive, hideHeader }: ResourceEditProps): React.ReactElement;
-//#endregion
-//#region src/resource/resource-edit-tabs.d.ts
-interface ResourceEditTabsProps extends ResourceEditProps {
-  /**
-   * The currently active tab key. Resolved against the VISIBLE tab set (see
-   * `resolveTabs`): an unknown / hidden value falls back to the `details` tab
-   * (the form) when present, else the first visible tab. Pass `undefined` to
-   * default to `details`.
-   */
-  activeTab?: string;
-  /**
-   * Called when the user clicks a tab trigger. Receives the new tab key
-   * (`details` for the form panel, otherwise the tab's `key`). Consumers
-   * typically wire this to a URL search-param so deep-links / back-forward
-   * navigation work. When omitted, falls back to internal state.
-   */
-  onTabChange?: (tab: string) => void;
-  /**
-   * Optional renderer for relation-tab list rows. Forwarded to the embedded
-   * `<ResourceList>`'s `rowHref`. Default behaviour produces
-   * `/{childResource}/{row.id}`.
-   */
-  subresourceRowHref?: (childResource: string, row: {
-    id: string;
-  }) => string;
-}
-/**
- * Renders `<ResourceEdit>` with a declarative tab strip resolved by the core
- * `resolveTabs` helper for the `'edit'` surface — the `details` tab hosts the
- * FORM, alongside any `component` / `relation` tabs declared on the resource /
- * template (and auto-generated relation tabs for every registered
- * subresource).
- *
- * The page header (back-link + the resolved `<ActionOverflow surface="edit">`
- * item-action list) is hoisted ABOVE the tab strip by the shared `DetailTabsShell`, so
- * edit-surface item actions stay visible on every tab. The `details` tab
- * therefore renders `<ResourceEdit>` chromeless (`hideHeader`).
- *
- * Fast path: when the resource declares no edit tabs and has no subresources,
- * this is a transparent passthrough to a plain `<ResourceEdit>` (own header,
- * no Tabs primitive in the tree).
- */
-declare function ResourceEditTabs(props: ResourceEditTabsProps): React.ReactElement | null;
-//#endregion
-//#region src/resource/resource-create.d.ts
-interface ResourceCreateProps {
-  resource: string;
-  defaults?: Record<string, unknown>;
-  onCreate: (values: Record<string, unknown>) => Promise<void>;
-  onCancel?: () => void;
-  className?: string;
-  /** Override the back-link href (defaults to the resource list page). */
-  backHref?: string;
-  /**
-   * Optional per-template field map. Forwarded to ResourceForm; keys override
-   * the resource-level `def.fields` on collision. Used by the document-
-   * templates v1 wiring on the playground create page.
-   */
-  fieldsOverride?: ResourceFieldMap;
-  /**
-   * Optional per-template layout override forwarded to ResourceForm. See
-   * `ResourceFormProps.fieldsLayoutOverride` — pass the matched template's
-   * `views?.fields` alongside `fieldsOverride`.
-   */
-  fieldsLayoutOverride?: FieldLayoutSpec;
-  /**
-   * Optional derived-value map forwarded to ResourceForm. See
-   * `ResourceFormProps.derive` — powers e.g. the preprint auto-name.
-   */
-  derive?: Record<string, (values: Record<string, unknown>) => unknown>;
-  /**
-   * Names what is being created, when the page knows something more specific
-   * than the resource label. A document create launched as `?type=order_code`
-   * should read «Создать: Заказ кодов», not the generic «Создать: Документ» —
-   * the user picked a type one screen ago and the title should confirm it.
-   * Omitted → the resource label is used, exactly as before.
-   */
-  typeLabel?: string;
-}
-declare function ResourceCreate({ resource, defaults, onCreate, onCancel, className, backHref, fieldsOverride, fieldsLayoutOverride, derive, typeLabel }: ResourceCreateProps): React.ReactElement;
-//#endregion
-//#region src/resource/document-type-picker.d.ts
-/** Text a host may substitute for a type's frozen declaration literals. */
-interface DocumentTypeText {
-  label?: string;
-  description?: string;
-}
-interface DocumentTypePickerProps {
-  /** The templated resource whose types are on offer. */
-  resource: string;
-  /**
-   * Called with the chosen type. Each card is a `<button>` when this is the
-   * only handler given.
-   */
-  onSelect?: (template: DocumentTemplate) => void;
-  /**
-   * Per-type href. Given this, each card is an anchor rendered through the
-   * installed `LinkComponent`, so it keeps SPA routing, middle-click and
-   * "open in new tab" — which a button cannot. Both may be passed: the
-   * anchor navigates and `onSelect` still fires.
-   */
-  hrefFor?: (template: DocumentTemplate) => string;
-  /**
-   * Substitute the declared `label` / `description` for one type — the seam
-   * for translated text. A resource declaration's literals are frozen at boot,
-   * so this is where a host hands back what it resolved from its i18n bundle.
-   * Anything omitted falls back to the declaration.
-   */
-  localize?: (template: DocumentTemplate) => DocumentTypeText;
-  /** Rendered when no type is on offer. Defaults to nothing at all. */
-  emptyState?: React$1.ReactNode;
-  className?: string;
-}
-/**
- * The create-page type picker: one card per document type a user may be
- * offered right now.
- *
- * **This is where four of `DocumentTemplate`'s keys are read.** `visible`
- * decides which types appear (through `useVisibleTemplates`, so the set
- * narrows the moment scope moves — a type declared
- * `visible: (ctx) => ctx.scope?.market !== 'EU'` leaves the offer when the
- * market becomes EU, with no code here that knows what a market is). `icon`
- * and `color` render the chip. `description` renders under the title. Until
- * SP6 task 3 the framework shipped a `DocumentTemplate` type describing this
- * component's card and no component: every adopter declaring types had to
- * write the picker themselves, and the three presentational keys did nothing
- * whatsoever in anyone's app.
- *
- * **It offers, it does not navigate and it does not authorize.** The host
- * decides what choosing a type means — usually pushing `?type=<type>` at its
- * own create route — because the URL contract belongs to the application's
- * router, not to a library component. And `visible` gates the OFFER only: a
- * hand-typed URL naming a hidden type still renders that type's form, exactly
- * as `ResourceConfig.visible` gates navigation rather than routes. Where the
- * boundary has to hold, declare a capability rule.
- */
-declare function DocumentTypePicker({ resource, onSelect, hrefFor, localize, emptyState, className }: DocumentTypePickerProps): React$1.ReactElement | null;
-//#endregion
-//#region src/resource/unsupported-document-type.d.ts
-interface UnsupportedDocumentTypeProps {
-  /** The templated resource whose declaration refused this value. */
-  resource: string;
-  /** The unrecognised discriminator value, or `null` when the record had none. */
-  typeValue: string | null;
-  className?: string;
-}
-/**
- * What `ResourceConfig.templates.fallback: 'unsupported'` renders.
- *
- * **This panel is a refusal, not an error.** The resource has declared that a
- * record whose document type it does not know must be named rather than
- * guessed at: rendering the host resource's whole field map instead would show
- * a person the union of every type's columns and let them believe that is what
- * the record is. A resource that would rather show that union simply omits
- * `fallback`, which is the default and changes nothing.
- *
- * The strings are the framework's own `create.unsupportedType` /
- * `create.unsupportedTypeHint`, in both shipped locales. They were added for
- * the one application that hand-wrote this panel, and until now that
- * application was their only reader — the same "the wiring works and its only
- * caller leaves" shape this component exists to close. The `create.` namespace
- * is now a misnomer (the show surface renders them too) and is kept anyway:
- * renaming would silently drop any adopter bundle that already shadows those
- * keys.
- *
- * `typeValue === null` — the record carries no discriminator at all — still
- * lands here, with the hint naming an empty type. See
- * `resolveTemplateProjection` for why the two are one outcome.
- */
-declare function UnsupportedDocumentType({ resource, typeValue, className }: UnsupportedDocumentTypeProps): React$1.ReactElement;
 //#endregion
 //#region src/resource/create-button.d.ts
 interface CreateButtonProps {
   /** Resource this creates. Required — the button gates itself. */
   resource: string;
-  /** Target create route, e.g. `resourceCreateHref(def, resource)`. */
+  /** Target create route, e.g. `resourceCreateHref(def, resource)`. Ignored with `onOpen`. */
   href: string;
+  /**
+   * Opens the create somewhere other than a route — a resource without a create page opens its
+   * `quick.create` (P3-19). The control is then a button, drawn when the entry gate answers
+   * `open` (inert with its reason when `disabled`, absent otherwise, and while access loads).
+   */
+  onOpen?: () => void;
   /** `data-testid` for the button. */
   testid?: string;
   size?: ButtonProps['size'];
@@ -5476,119 +5126,14 @@ interface CreateButtonProps {
  * nothing for `absent`/`hidden`, a focusable `aria-disabled` control with a
  * toast reason for `disabled`, and the normal link for `available`.
  */
-declare function CreateButton({ resource, href, testid, size, variant, label, className }: CreateButtonProps): React.ReactElement | null;
-//#endregion
-//#region src/resource/resource-form.d.ts
-interface ResourceFormProps {
-  resource: string;
-  view: 'edit' | 'create';
-  recordId?: string;
-  initialValues: Record<string, unknown>;
-  onSubmit: (values: Record<string, unknown>) => Promise<void>;
-  onCancel?: () => void;
-  className?: string;
-  submitLabel?: string;
-  /**
-   * Optional per-context field map MERGED over the resource-level
-   * `def.fields`. Keys present here win over keys of the same name on the
-   * resource; keys only on the resource still render. It means "specialize or
-   * add these keys for this render".
-   *
-   * ⚠️ **This is not how a document type projects its field set.** A templated
-   * resource resolves that itself — the form reads
-   * `initialValues[templates.discriminatorField]`, matches the template and
-   * renders the template's OWN field map (a replacement, not a merge). Passing
-   * `fieldsOverride` turns that resolution OFF for this render, because an
-   * explicit map outranks an inferred one. Adopters wiring a template by hand
-   * (as the since-deleted `apps/playground` did before the resolution was
-   * promoted) therefore
-   * keep exactly the behaviour they had.
-   */
-  fieldsOverride?: ResourceFieldMap;
-  /**
-   * Optional layout override for the shared `views.fields` declaration — the
-   * same idea as `fieldsOverride`, one tier up: when set, it REPLACES
-   * `views.form.fields ?? views.fields` outright for this render.
-   *
-   * Precedence: this prop → the matched template's `views.fields` → the
-   * resource's own. A template's declared order wins over the resource's
-   * because merging two orders has no meaning anyone could predict.
-   *
-   * Ignored when `fieldsFilter` is set — a wizard step's hand-picked order
-   * already wins outright over any shared layout declaration.
-   */
-  fieldsLayoutOverride?: FieldLayoutSpec;
-  /**
-   * Optional whitelist of field names to render. When set, only the listed
-   * fields are visible inside the form (in array order); every other field
-   * declared on the resource is hidden. Used by `<ResourceWizard>` to
-   * project a slice of the resource's field set into a single step.
-   *
-   * Differs from `fieldsOverride` (which adds / replaces fields). Permission
-   * (`visible`) gates and the create-view "system field" rule still apply
-   * on top of this filter — a field listed here that fails `visible(ctx)`
-   * still does not render.
-   *
-   * Empty array (`[]`) renders zero inputs (the canonical
-   * "summary / confirm" wizard step shape). Field names not present on
-   * the resource def are silently ignored at render time.
-   */
-  fieldsFilter?: string[];
-  /**
-   * Optional override of the form-level cross-field validator. When
-   * provided, this validator runs in place of the resource's own
-   * `def.validate`. Used by `<ResourceWizard>` to attach step-level
-   * validation that wraps the form's normal lifecycle. Adopters who
-   * just want the resource-level validate should leave this undefined.
-   */
-  validateOverride?: ResourceValidator;
-  /**
-   * Optional override of the submit button's label. When omitted the
-   * form falls back to `submitLabel` (existing prop) and then to the
-   * default ('Save' / 'Create' depending on view).
-   */
-  hideCancelButton?: boolean;
-  /**
-   * @internal
-   * Optional callback that mirrors in-progress field values to a parent.
-   * The form invokes this AFTER each setFieldValue, but deferred to a
-   * microtask via queueMicrotask() so the parent's setState (if any) does
-   * not interleave with the form's own state updates.
-   *
-   * Used by ResourceWizard to mirror typed-but-not-yet-Next-ed values
-   * across step boundaries. Adopters generally should not need this; if
-   * they do, they MUST tolerate the microtask deferral and any throw
-   * inside the callback (errors are caught + console.error'd, but the
-   * form continues).
-   *
-   * Stable reference is NOT required — ResourceForm reads via the
-   * latest render's prop, not a memoized closure.
-   */
-  onValuesChange?: (values: Record<string, unknown>) => void;
-  /**
-   * Optional derived-value map: `targetField → (values) => computed`. Each
-   * target is auto-filled from the other live form values UNTIL the user edits
-   * it directly — or it already carried a value on mount (an edit form with a
-   * saved value is never auto-overwritten). A nullish/empty computed value
-   * never overwrites. This is the framework mechanism behind the preprint
-   * auto-name («<gtin> x <quantity> (<name>)»), replacing a bespoke per-form
-   * effect — same spirit as the `visible(ctx, values)` predicates, but writing
-   * a value instead of gating render.
-   *
-   * ⚠️ A templated resource resolves this itself: the matched document type's
-   * own `derive` map applies with no prop passed at all. This prop OVERRIDES
-   * that map wholesale for the render — it does not merge with it.
-   */
-  derive?: Record<string, (values: Record<string, unknown>) => unknown>;
-}
-declare function ResourceForm(props: ResourceFormProps): React.ReactElement | null;
+declare function CreateButton({ resource, href, testid, size, variant, label, className, onOpen }: CreateButtonProps): React.ReactElement | null;
 //#endregion
 //#region src/resource/form-context.d.ts
 /**
  * Minimal form-control handle exposed to field renderers so a field can update
  * SIBLING fields (a field renderer otherwise only sees its own value). Used for
  * reactive prefills — e.g. picking a product on a GTIN field also fills the
- * «Название товара» / «Тип кода» fields (#2). `<ResourceForm>` provides it.
+ * «Название товара» / «Тип кода» fields (#2). `<RecordScreen>` provides it.
  */
 interface FormControl {
   /** Merge a patch of `{ fieldName: value }` into the form's live values. */
@@ -5597,74 +5142,6 @@ interface FormControl {
 /** Read the surrounding form's control handle, or `null` outside a form. */
 declare function useFormControl(): FormControl | null;
 //#endregion
-//#region src/resource/resource-wizard.d.ts
-interface ResourceWizardProps<TValues = Record<string, unknown>> {
-  /** Wizard definition produced by `defineResourceWizard`. */
-  def: ResourceWizardDef<TValues>;
-  /** Optional initial form values (seeded into step 1). */
-  initialValues?: Partial<TValues>;
-  /**
-   * Called once when the user clicks Submit on the LAST step AND every
-   * step's validators (per-field + step-level + form-level) pass. Receives
-   * the full accumulated values across every step.
-   */
-  onSubmit: (values: TValues) => Promise<void>;
-  /**
-   * Called when the user clicks the Cancel button on any step. Adopters
-   * typically wire this to `router.back()` or `router.push(listUrl)`.
-   * Values are discarded — there is no draft persistence in v0.2.
-   */
-  onCancel?: () => void;
-  /**
-   * Optional view label (defaults to 'create'). Forwarded to the
-   * underlying `<ResourceForm>` instance for testid + system-field
-   * gating semantics.
-   */
-  view?: 'create' | 'edit';
-  /** Optional record id when editing an existing record. */
-  recordId?: string;
-  /**
-   * Per-template field map override (forwarded to ResourceForm). Used
-   * when the wizard renders a templated resource and the adopter wants
-   * the matched template's field set on each step.
-   */
-  fieldsOverride?: ResourceFieldMap;
-  className?: string;
-}
-/**
- * Multi-step form built on top of `<ResourceForm>`. Each step renders
- * one `<ResourceForm>` configured with a slice of the resource's
- * fields (`fieldsFilter`) plus an optional step-level validator
- * (`validateOverride`). The wizard owns the step index, the
- * accumulated values across steps, and the Next / Back / Submit /
- * Cancel button rail.
- *
- * Behavior:
- *  - Step 0 renders on mount.
- *  - Next: runs the step's validators (per-field + step.validate);
- *    if all pass, advances to step + 1.
- *  - Back: decrements the step (no validation) and preserves values.
- *  - Submit (last step): runs validators; on pass calls
- *    `onSubmit(values)` with the FULL accumulated values map.
- *  - Cancel: calls `onCancel?.()`.
- *
- * The progress indicator above the body shows every step with the
- * current step highlighted. Completed steps (anything left of the
- * current step) are clickable — clicking jumps back without
- * re-validation. Future steps are disabled until reached.
- *
- * Edge cases:
- *  - Empty `fields[]` step → renders no inputs (summary / confirm
- *    pattern). Submit on a single-step wizard skips Next/Back entirely.
- *  - Step values persist across Back navigation — the wizard owns the
- *    values map directly; ResourceForm receives a fresh `initialValues`
- *    prop each render keyed off step id so its internal state resets
- *    to the wizard's snapshot.
- *  - Hidden / conditional fields per step are honored by ResourceForm
- *    (B3) via the values context the wizard threads through.
- */
-declare function ResourceWizard<TValues = Record<string, unknown>>(props: ResourceWizardProps<TValues>): React.ReactElement | null;
-//#endregion
 //#region src/ui-presentations/dialog-host.d.ts
 /**
  * Concrete `dialog` host for `BuroProvider`'s `presentationHosts` prop:
@@ -5679,6 +5156,24 @@ declare namespace DialogPresentationHost {
     title: "string";
     description: "string";
     wrapper: "boolean";
+    ownTitle: "boolean";
+  }>;
+}
+//#endregion
+//#region src/ui-presentations/popover-host.d.ts
+/**
+ * Concrete `popover` host for `BuroProvider`'s `presentationHosts` prop (spec 4.1, 4.12): a
+ * non-modal Radix popover positioned against the request's `anchor.element`. Focus stays on the
+ * anchor (nothing is focused on open, nothing is restored on close); the content is a
+ * `role="dialog"` named by the presented screen. It closes through the guarded `dismiss()` on
+ * Escape, on a pointer down outside it, when focus moves elsewhere, when the pointer has been off
+ * both the anchor and the popover for {@link POPOVER_LEAVE_GRACE_MS}, and when the anchor leaves
+ * the document.
+ */
+declare function PopoverPresentationHost({ component: Component, props, options, anchor }: UIPresentationHostProps): ReactElement | null;
+declare namespace PopoverPresentationHost {
+  var optionsSchema: Readonly<{
+    title: "string";
   }>;
 }
 //#endregion
@@ -5690,6 +5185,7 @@ declare namespace SheetPresentationHost {
     title: "string";
     description: "string";
     wrapper: "boolean";
+    ownTitle: "boolean";
   }>;
 }
 //#endregion
@@ -5702,12 +5198,18 @@ interface PresentationShellProps {
   readonly dismiss: () => void;
   readonly wrapper: boolean;
   readonly copy: PresentationCopy;
+  /**
+   * The presented component renders the overlay's title itself, as the Radix `Title` (a quick
+   * entry's record title, plan ruling 2): the shell renders no title and no description, and
+   * focus moves to the element marked `data-buro-overlay-heading` on open.
+   */
+  readonly ownTitle?: boolean;
   readonly children: ReactNode;
 }
 /** Shared Radix lifecycle shell for a centered temporary presentation. */
-declare function DialogPresentationShell({ dismiss, wrapper, copy, children }: PresentationShellProps): import("react/jsx-runtime").JSX.Element;
+declare function DialogPresentationShell({ dismiss, wrapper, copy, ownTitle, children }: PresentationShellProps): import("react/jsx-runtime").JSX.Element;
 /** Shared Radix lifecycle shell for a right-hand temporary presentation. */
-declare function SheetPresentationShell({ dismiss, wrapper, copy, children }: PresentationShellProps): import("react/jsx-runtime").JSX.Element;
+declare function SheetPresentationShell({ dismiss, wrapper, copy, ownTitle, children }: PresentationShellProps): import("react/jsx-runtime").JSX.Element;
 //#endregion
 //#region src/ui-presentations/copy.d.ts
 /**
@@ -5723,9 +5225,14 @@ declare function wrapperEnabled(options: Readonly<Record<string, unknown>>): boo
 //#endregion
 //#region src/ui-presentations/index.d.ts
 /**
- * Concrete dialog/sheet hosts for `BuroProvider`'s `presentationHosts`
- * prop, keyed by `UIPresentationDescriptor['host']`. Pass this straight
- * through: `<BuroProvider presentationHosts={shadcnPresentationHosts} .../>`.
+ * Concrete dialog/sheet/popover hosts for `BuroProvider`'s `presentationHosts`
+ * prop, keyed by `UIPresentationDescriptor['host']`, and the kit's overlay
+ * screens (`screens.quick`: a record's quick entry; `screens.peek`: the hover
+ * preview of a relation display's record; `screens.flow`: a flow's host,
+ * loaded on first use). Pass this straight through:
+ * `<BuroProvider presentationHosts={shadcnPresentationHosts} .../>`; an app
+ * with hosts of its own keeps quick entries and flows by spreading
+ * `shadcnPresentationHosts.screens` into them.
  */
 declare const shadcnPresentationHosts: UIPresentationHosts;
 //#endregion
@@ -5747,6 +5254,8 @@ type IconComponent = ComponentType<SVGProps<SVGSVGElement>>;
  * ```
  */
 declare function registerIcons(map: Record<string, IconComponent>): void;
+/** Whether `name` is a registered icon (built-in or via {@link registerIcons}). */
+declare function hasIcon(name: string): boolean;
 interface IconProps {
   /** Semantic registry key (e.g. `'Hash'`). See REGISTRY above. */
   name?: string;
@@ -6048,7 +5557,7 @@ type FormItemProps = React$1.HTMLAttributes<HTMLDivElement>;
 declare const FormItem: React$1.ForwardRefExoticComponent<FormItemProps & React$1.RefAttributes<HTMLDivElement>>;
 type FormLabelProps = React$1.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>;
 declare const FormLabel: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & React$1.RefAttributes<HTMLLabelElement>>;
-type FormControlProps = React$1.ComponentPropsWithoutRef<typeof Slot>;
+type FormControlProps = React$1.ComponentPropsWithoutRef<typeof Slot$1>;
 type FormDescriptionProps = React$1.HTMLAttributes<HTMLParagraphElement>;
 declare const FormDescription: React$1.ForwardRefExoticComponent<FormDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
 type FormMessageProps = React$1.HTMLAttributes<HTMLParagraphElement>;
@@ -6163,7 +5672,7 @@ declare const Label: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.Label
 //#region src/primitives/tabs.d.ts
 /**
  * Thin shadcn-ui-style wrapper around `@radix-ui/react-tabs`. Exposed as
- * a primitive so feature components (e.g. ResourceShowTabs) can compose
+ * a primitive so feature components (e.g. the screen tree's tabs node) can compose
  * the standard accessible Tabs pattern without re-implementing radix
  * boilerplate.
  *
@@ -6238,18 +5747,20 @@ type SidebarContextValue = {
   toggleSidebar: () => void;
 };
 declare function useSidebar(): SidebarContextValue;
+/** The sidebar context, or `null` outside a `SidebarProvider`. Never throws. */
+declare function useOptionalSidebar(): SidebarContextValue | null;
 interface SidebarProviderProps extends React$1.ComponentPropsWithoutRef<'div'> {
   defaultOpen?: boolean;
   open?: boolean;
   onOpenChange?: (open: boolean) => void;
 }
 declare const SidebarProvider: React$1.ForwardRefExoticComponent<SidebarProviderProps & React$1.RefAttributes<HTMLDivElement>>;
-interface SidebarProps$1 extends React$1.ComponentPropsWithoutRef<'div'> {
+interface SidebarProps extends React$1.ComponentPropsWithoutRef<'div'> {
   side?: 'left' | 'right';
   variant?: 'sidebar' | 'floating' | 'inset';
   collapsible?: 'offcanvas' | 'icon' | 'none';
 }
-declare const Sidebar$1: React$1.ForwardRefExoticComponent<SidebarProps$1 & React$1.RefAttributes<HTMLDivElement>>;
+declare const Sidebar: React$1.ForwardRefExoticComponent<SidebarProps & React$1.RefAttributes<HTMLDivElement>>;
 declare const SidebarTrigger: React$1.ForwardRefExoticComponent<Omit<ButtonProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
 declare const SidebarRail: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
 declare const SidebarInset: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React$1.RefAttributes<HTMLElement>>;
@@ -6270,7 +5781,7 @@ declare const SidebarMenu: React$1.ForwardRefExoticComponent<Omit<React$1.Detail
 declare const SidebarMenuItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
 declare const sidebarMenuButtonVariants: (props?: ({
   variant?: "default" | "outline" | null | undefined;
-  size?: "default" | "sm" | "lg" | null | undefined;
+  size?: "sm" | "lg" | "default" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 interface SidebarMenuButtonProps extends React$1.ComponentPropsWithoutRef<'button'>, VariantProps<typeof sidebarMenuButtonVariants> {
   asChild?: boolean;
@@ -6466,9 +5977,248 @@ declare const typography: {
 };
 type TypographyKey = keyof typeof typography;
 //#endregion
+//#region src/shell/shell-context.d.ts
+interface ShellBrand {
+  readonly name: string;
+  readonly subtitle?: string;
+  readonly logo?: ReactNode;
+  /** Where the brand links to. Default `'/'`. */
+  readonly homePath?: string;
+}
+interface ShellUser {
+  readonly name: string;
+  readonly email?: string;
+  readonly avatarUrl?: string;
+  readonly initials: string;
+}
+/** Maps the auth provider's identity to what the shell shows. `initials` is derived from `name`. */
+type ShellUserMapper = (identity: unknown) => Omit<ShellUser, 'initials'>;
+interface ShellContextValue {
+  readonly brand?: ShellBrand;
+  readonly mapUser: ShellUserMapper;
+  /** Where sign-out and "Sign in" go. Default `'/login'`. */
+  readonly loginPath: string;
+  /** Set only when a command palette is mounted. */
+  readonly openPalette?: () => void;
+  /** The mounted palette's open state; `AppShell` sets it unless `palette={false}`. Read it with {@link usePaletteState}. */
+  readonly palette?: PaletteState;
+}
+interface PaletteState {
+  readonly open: boolean;
+  readonly setOpen: (open: boolean) => void;
+}
+/** `name`, else `email`, else `id` for the name; `email`; `avatarUrl` else `avatar`. */
+declare function defaultUserMapper(identity: unknown): Omit<ShellUser, 'initials'>;
+type ShellProviderProps = Partial<ShellContextValue> & {
+  readonly children: ReactNode;
+};
+declare function ShellProvider({ brand, mapUser, loginPath, openPalette, palette, children }: ShellProviderProps): ReactElement;
+/** Outside a `ShellProvider`: no brand, the default mapper, `/login`. */
+declare function useShell(): ShellContextValue;
+/**
+ * The palette's `open` and `setOpen`, for a custom `AppShell palette={<MyPalette/>}`, which
+ * receives no props. Throws outside an `AppShell` (or a `ShellProvider` given `palette`).
+ */
+declare function usePaletteState(): PaletteState;
+//#endregion
+//#region src/shell/use-current-user.d.ts
+interface CurrentUser {
+  readonly user: ShellUser | null;
+  /** The identity is being fetched. `false` for a query that is idle (session not ready) or absent. */
+  readonly isLoading: boolean;
+  /** `false` when the app has no `authProvider`: there is no identity to show and no logout to run. */
+  readonly available: boolean;
+  /**
+   * Logs out, then goes to the shell's `loginPath`; stays put on `{ success: false }`. Returns the
+   * result. Rejects when the auth provider's `logout` throws instead of returning a result.
+   */
+  readonly signOut: () => Promise<AuthResult>;
+}
+/**
+ * The signed-in user as the shell shows it. Never throws: without an `authProvider` it reports
+ * `available: false` and no user.
+ */
+declare function useCurrentUser(): CurrentUser;
+//#endregion
+//#region src/shell/sidebar-brand.d.ts
+/** The brand tile, name and subtitle at the top of the sidebar; reads `AppShell brand` / `ShellProvider brand`. */
+declare function SidebarBrand(): ReactElement | null;
+//#endregion
+//#region src/shell/brand-mark.d.ts
+/**
+ * The `ShellProvider` brand as a standalone mark — `SidebarBrand` without the sidebar button.
+ * `AuthPage` shows it when given no `brand`. Renders nothing without a brand.
+ */
+declare function BrandMark(): ReactElement | null;
+//#endregion
+//#region src/shell/use-nav-icon.d.ts
+/**
+ * Resolve a nav icon NAME to a node: a Components-registry slot of that key
+ * first, then the `registerIcons` registry. An unknown name yields `undefined`
+ * (no placeholder circle) and, outside production, warns once per name.
+ */
+declare function resolveNavIcon(name: string | undefined, components: (key: string) => unknown): ReactNode | undefined;
+/** `resolveNavIcon` bound to the Components registry in context. */
+declare function useNavIcon(): (name: string | undefined) => ReactNode | undefined;
+//#endregion
+//#region src/shell/app-shell.d.ts
+/** Every slot follows {@link Slot}: omit for the default, `false` for nothing, an element to replace. */
+interface AppShellProps {
+  /** Read by `SidebarBrand`, `AuthPage` and the document title. */
+  brand: ShellBrand;
+  /** Maps the auth provider's identity to what the user menu shows. Default: `defaultUserMapper`. */
+  user?: ShellUserMapper;
+  /** Where sign-out and "Sign in" go. Default `'/login'`. */
+  loginPath?: string;
+  /** Default `<AppSidebar />`. `false` gives a header-only layout with no sidebar trigger. */
+  sidebar?: Slot;
+  /** Default `<AppHeader />`. */
+  header?: Slot;
+  /**
+   * Default `<DefaultCommandPalette />`. `false` removes the palette, the ⌘K / Ctrl+K shortcut
+   * and the header's search chip. A custom element receives no props: it reads `open` and
+   * `setOpen` from `usePaletteState()`.
+   */
+  palette?: Slot;
+  /** Passed to `AppLayout`, typically `<DocPanel />`. */
+  docPanel?: ReactNode;
+  children: ReactNode;
+}
+/**
+ * `AppLayout` with the default sidebar, header and command palette, and the brand and user
+ * context they read. Renders inside `BuroProvider`, a `RouterAdapter` and a
+ * `LinkComponentProvider`; it does not boot the runtime, own routes or guard auth.
+ */
+declare function AppShell({ brand, user, loginPath, sidebar, header, palette, docPanel, children }: AppShellProps): ReactElement;
+//#endregion
+//#region src/shell/default-command-palette.d.ts
+interface DefaultCommandPaletteProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  /** Appended to the Actions group after theme, language and sign out. */
+  actions?: ActionItem[];
+  /** Replaces every group. The dialog, input, empty state and footer stay. */
+  children?: ReactNode;
+}
+/**
+ * The palette `AppShell` mounts by default: Docs, Recent, Records, Navigation, Create and
+ * Actions, in that order. Records needs a data runtime and is left out without one. Actions are the theme choices, the languages (only with more than
+ * one locale), "Sign out" (only when someone is signed in) and then `actions`.
+ */
+declare function DefaultCommandPalette({ open, onOpenChange, actions, children }: DefaultCommandPaletteProps): ReactElement;
+//#endregion
+//#region src/shell/scope-switcher.d.ts
+interface ScopeOption {
+  value: string;
+  label: string;
+  description?: string;
+  icon?: ReactNode;
+}
+interface ScopeSwitcherProps {
+  options: readonly ScopeOption[];
+  value: string | null;
+  /** A rejection is swallowed here and leaves the value unchanged; the caller reports the error. */
+  onChange: (value: string) => void | Promise<void>;
+  /** Dropdown heading, e.g. "Tenant". */
+  label?: string;
+  /** Rows rendered after a separator, e.g. an "Administration" item. */
+  extra?: ReactNode;
+  /** Shown when `value` is null. */
+  placeholder?: string;
+}
+/** A sidebar-header picker for the current tenant, workspace or other scope. */
+declare function ScopeSwitcher({ options, value, onChange, label, extra, placeholder }: ScopeSwitcherProps): ReactElement;
+//#endregion
+//#region src/shell/user-menu.d.ts
+interface UserMenuProps {
+  /** `'sidebar'`: the sidebar-footer row (avatar, name, email). `'avatar'`: a round avatar button for a header. Default `'sidebar'`. */
+  variant?: 'sidebar' | 'avatar';
+  /**
+   * The menu's parts, in the order given. Omit to get the default set: Profile, Theme, Language
+   * (only with more than one locale) and Sign out. Passed parts always render. Signed out, the
+   * menu shows the passed parts except `Profile` and `SignOut`, then "Sign in"; the default set
+   * signed out is Theme, Language and "Sign in".
+   */
+  children?: ReactNode;
+}
+declare function Profile(): ReactElement;
+declare function Theme(): ReactElement;
+declare function Language(): ReactElement | null;
+declare function Separator$1(): ReactElement;
+type ItemProps = {
+  id: string;
+  label: ReactNode;
+  icon?: ReactNode;
+} & ({
+  href: string;
+  onSelect?: never;
+} | {
+  onSelect: () => void;
+  href?: never;
+});
+declare function Item(props: ItemProps): ReactElement;
+declare function SignOut(): ReactElement;
+declare function UserMenuRoot({ variant, children }: UserMenuProps): ReactElement | null;
+/**
+ * The user's menu. Fills each part you do not pass with its default; passed children replace
+ * the default set. `UserMenu.Profile`, `.Theme`, `.Language`, `.Separator`, `.Item` and
+ * `.SignOut` are the parts. Signed out it is still a menu — the parts that need no identity,
+ * then "Sign in" (`user-menu:sign-in`) — so theme and language stay reachable. Renders nothing
+ * without an auth provider.
+ */
+declare const UserMenu: typeof UserMenuRoot & {
+  Profile: typeof Profile;
+  Theme: typeof Theme;
+  Language: typeof Language;
+  Separator: typeof Separator$1;
+  Item: typeof Item;
+  SignOut: typeof SignOut;
+};
+//#endregion
+//#region src/shell/use-language-switch.d.ts
+interface LanguageSwitchApi {
+  /** The active locale code. */
+  readonly locale: string;
+  /** Every locale the app can switch to; just the active one when the i18n facade does not list them. */
+  readonly locales: readonly string[];
+  /** Switch the live locale (no reload) and persist the choice under the provider's `languageStorageKey`. */
+  readonly change: (code: string) => void;
+}
+/**
+ * The headless model behind every language control: the active locale, the
+ * locales on offer, and a `change` that switches live and remembers the pick.
+ * `<LanguageSwitch>`, `<LanguageSubmenu>` and the palette actions are views
+ * over it; an app's own control can be one too.
+ */
+declare function useLanguageSwitch(): LanguageSwitchApi;
+//#endregion
+//#region src/shell/theme-controls.d.ts
+/** Radio submenu over {@link THEME_CHOICES}, bound to the stored choice (not the resolved theme). */
+declare function ThemeSubmenu(): ReactElement;
+/** Icon button cycling light, dark, system. The icon shows the current choice. */
+declare function ThemeToggle(): ReactElement;
+/** One command-palette action per theme choice. */
+declare function useThemePaletteActions(): ActionItem[];
+//#endregion
+//#region src/shell/language-submenu.d.ts
+/**
+ * A locale's name in its own language ("English", "Русский", "Français"),
+ * capitalised. Falls back to the bare code when `Intl.DisplayNames` does not
+ * know it (or the code is not a valid BCP-47 tag).
+ */
+declare function localeLabel(code: string): string;
+/**
+ * Radio submenu over the app's locales. Renders nothing only when there is no
+ * i18n facade; with one locale it still renders that one choice (hiding a
+ * single-locale row is the default menu's decision, not this part's).
+ */
+declare function LanguageSubmenu(): ReactElement | null;
+/** One command-palette action per locale; empty unless the app has more than one. */
+declare function useLanguagePaletteActions(): ActionItem[];
+//#endregion
 //#region src/index.d.ts
 declare const PACKAGE_NAME: "@burojs/ui-shadcn";
 declare const PACKAGE_VERSION: "0.0.0";
 //#endregion
-export { ActionButton, type ActionButtonProps, ActionConfirmDialog, type ActionConfirmDialogProps, type ActionItem, ActionOverflow, type ActionOverflowProps, type ActionSurface, AlertDialog, AlertDialogAction, AlertDialogActionProps, AlertDialogCancel, AlertDialogCancelProps, AlertDialogContent, AlertDialogContentProps, AlertDialogDescription, AlertDialogDescriptionProps, AlertDialogFooter, AlertDialogFooterProps, AlertDialogHeader, AlertDialogHeaderProps, AlertDialogOverlay, AlertDialogOverlayProps, AlertDialogPortal, AlertDialogTitle, AlertDialogTitleProps, AlertDialogTrigger, AppHeader, type AppHeaderProps, AppLayout, type AppLayoutProps, AppSidebar, type AppSidebarProps, AuthPage, type AuthPageProps, Avatar, AvatarFallback, AvatarImage, Badge, BadgeProps, BooleanDisplay, BooleanInput, Breadcrumbs, type BreadcrumbsProps, type BuildNavItemsArgs, BulkActionToolbar, type BulkActionToolbarProps, Button, ButtonProps, Card, CardContent, CardContentProps, CardDescription, CardDescriptionProps, CardFooter, CardFooterProps, CardHeader, CardHeaderProps, CardProps, CardTitle, CardTitleProps, CheckConfirmDialog, type CheckConfirmDialogProps, Checkbox, CheckboxProps, Collapsible, CollapsibleContent, CollapsibleTrigger, ColumnsToggle, Command, CommandDialog, CommandDialogProps, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandLoading, CommandLoadingProps, CommandPalette, CommandPaletteActionsGroup, type CommandPaletteActionsGroupProps, type CommandPaletteActionsTestIdRole, CommandPaletteCreateGroup, type CommandPaletteCreateGroupProps, type CommandPaletteCreateTestIdRole, CommandPaletteDocsGroup, type CommandPaletteDocsGroupProps, CommandPaletteNavigationGroups, type CommandPaletteNavigationGroupsProps, type CommandPaletteNavigationTestIdRole, type CommandPaletteProps, CommandPaletteRecentGroup, type CommandPaletteRecentGroupProps, type CommandPaletteRecentTestIdRole, CommandPaletteRecordsGroup, type CommandPaletteRecordsGroupProps, type CommandPaletteRecordsTestIdRole, type CommandPaletteTestIdRole, CommandPaletteTrigger, type CommandPaletteTriggerProps, CommandSeparator, ContextPicker, type ContextPickerProps, CreateButton, type CreateButtonProps, CursorLoadMore, type CursorLoadMoreProps, DEFAULT_LANGUAGE, DEFAULT_LANGUAGE_STORAGE_KEY, DataTable, DataTableDateRangeFilter, type DataTableDateRangeFilterProps, DataTableEnumFilter, type DataTableEnumFilterProps, DataTableFacetedFilter, type DataTableFacetedFilterProps, DataTableNumRangeFilter, type DataTableNumRangeFilterProps, DataTableOperatorFilter, type DataTableOperatorFilterProps, type DataTableProps, DataTableRowActions, type DataTableRowActionsProps, DataTableTextFilter, type DataTableTextFilterProps, DataTableToolbar, type DataTableToolbarProps, DataTableViewOptions, type DataTableViewOptionsProps, DateDisplay, DateInput, DeclarativeDisplay, type DeclarativeDisplayProps, DeclarativeForm, type DeclarativeFormProps, type DeclarativeFormSlots, DetailTabsShell, type DetailTabsShellProps, Dialog, DialogClose, DialogContent, DialogContentProps, DialogDescription, DialogDescriptionProps, type DialogFilterState, DialogFooter, DialogFooterProps, DialogHeader, DialogHeaderProps, DialogOverlayProps, DialogPresentationHost, DialogPresentationShell, DialogTitle, DialogTitleProps, DialogTrigger, DisabledAction, type DisabledActionProps, DispatcherProvider, type DispatcherProviderProps, DocBrowser, type DocBrowserProps, DocInfo, type DocInfoProps, DocPanel, type DocPanelProps, DocTrailHelp, type DocTrailHelpProps, DocumentTitleProvider, DocumentTypePicker, type DocumentTypePickerProps, type DocumentTypeText, type DraftRemovalSignal, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, ENUM_PICKER_CLEAR_SENTINEL, EditPageHeader, EnumBadge, type EnumBadgeProps, EnumDisplay, EnumInput, EnumPicker, type EnumPickerProps, type EnumPickerRenderAs, EnumDisplay$1 as EnumValueDisplay, type EnumDisplayProps as EnumValueDisplayProps, type EnumDisplayVariant as EnumValueDisplayVariant, ExportButton, type ExportButtonProps, ExportDialog, type ExportDialogProps, type FacetedFilterOption, Field, FieldDisplay, type FieldDisplayProps, type FieldProps, FileDisplay, FileField, type FileFieldProps, FileInput, type FileInputProps, FilterBadges, type FilterBadgesProps, FilterBuilder, type FilterBuilderProps, type FilterOperator, FilterPanel, type FilterPanelProps, FilterRegion, FilterValueControl, type FilterValueControlProps, Form, FormControl, FormControlProps, FormDescription, FormDescriptionProps, FormField, FormItem, FormItemProps, FormLabel, FormLabelProps, FormMessage, FormMessageProps, Icon, IconComponent, IconProps, Input, InputProps, Label, LabelProps, type LanguageCode, LanguageSwitch, type LanguageSwitchProps, Sidebar as LegacySidebar, type SidebarProps as LegacySidebarProps, type LinkComponent, type LinkComponentProps, LinkComponentProvider, type LinkComponentProviderProps, type ListCellRenderer, ListErrorState, type ListErrorStateProps, ListSearchInput, type ListSlot, type ListSlotRegion, type LoginCredentials, LoginForm, type LoginFormProps, NavAreaLayout, type NavAreaLayoutProps, NavAreaPage, NavChrome, NavChromeBoundaryProvider, type NavChromeProps, type NavItem, type NavLayout, type NavLayoutProps, NavMain, type NavMainProps, NavUser, type NavUserProps, type NavigateFn, NavigationGuardProvider, NumberDisplay, NumberInput, PACKAGE_NAME, PACKAGE_VERSION, PageHeader, type PageHeaderProps, PinnedFilterControls, type PinnedFilterControlsProps, Popover, PopoverAnchor, PopoverClose, PopoverContent, PopoverContentProps, PopoverTrigger, type PresentationCopy, Progress, ProgressProps, RelationDisplay, RelationField, RelationPicker, RelationPickerDialog, type RelationPickerDialogProps, RelationPickerInput, type RelationPickerProps, type ResolvedTheme, ResourceCreate, type ResourceCreateProps, ResourceEdit, type ResourceEditProps, ResourceEditTabs, type ResourceEditTabsProps, ResourceForm, type ResourceFormProps, ResourceList, ResourceListPage, type ResourceListPageProps, type ResourceListProps, ResourcePageRouter, type ResourcePageRouterProps, ResourceShow, type ResourceShowBannerProps, type ResourceShowProps, ResourceShowTabs, type ResourceShowTabsProps, ResourceWizard, type ResourceWizardProps, type RowActionDescriptor, SavedViewsDropdown, type SavedViewsDropdownProps, SecondarySidebarLayout, Select, SelectContent, SelectContentProps, SelectGroup, SelectItem, SelectItemProps, SelectLabel, SelectLabelProps, SelectScrollDownButton, SelectScrollDownButtonProps, SelectScrollUpButton, SelectScrollUpButtonProps, SelectSeparator, SelectSeparatorProps, SelectTrigger, SelectTriggerProps, SelectValue, Separator, Sheet, SheetClose, SheetContent, SheetContentProps, SheetDescription, SheetDescriptionProps, SheetFooter, SheetFooterProps, SheetHeader, SheetHeaderProps, SheetOverlayProps, SheetPresentationHost, SheetPresentationShell, SheetTitle, SheetTitleProps, SheetTrigger, ShowPageHeader, Sidebar$1 as Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuButtonProps, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubButtonProps, SidebarMenuSubItem, SidebarProps$1 as SidebarProps, SidebarProvider, SidebarProviderProps, SidebarRail, SidebarSeparator, SidebarTrigger, Skeleton, type SpacingKey, SubresourceTabBody, THEME_STORAGE_KEY, TabBody, type TabBodyProps, type TabComponentProps, Table, TableBody, TableBodyProps, TableCaption, TableCaptionProps, TableCell, TableCellProps, TableHead, TableHeadProps, TableHeader, TableHeaderProps, TableProps, TableRow, TableRowProps, Tabs, TabsContent, TabsContentProps, TabsLayout, TabsList, TabsListProps, TabsTrigger, TabsTriggerProps, TaskRunPanel, TaskRunPanelProps, TextDisplay, TextInput, Textarea, TextareaDisplay, TextareaInput, TextareaProps, type ThemeChoice, Toaster, type ToasterProps, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TypographyKey, UnsupportedDocumentType, type UnsupportedDocumentTypeProps, type UseBuroDataTableOptions, type UseDialogFilterStateOptions, type UseThemeResult, badgeVariants, buildNavItems, buroSortingToTanStack, buttonVariants, cn, createNotificationProvider, defaultNavLayouts, downloadArtifact, formatOperatorLabel, i18nPrefixToRef, isImage, layoutSlot, listSlot, loadLanguage, loadLocale, modeForSurface, pageSlot, recordDisplayName, registerIcons, relationLinkClassName, resolveUpdater, saveLanguage, saveLocale, shadcnFieldImplementations, shadcnPresentationHosts, spacing, tabSlot, tanStackSortingToBuro, toast, typography, useBuroDataTable, useCurrentPath, useDialogFilterState, useDispatcher, useDocumentTitle, useExportRunWatcher, useFormControl, useFormField, useHref, useIsMobile, useLayout, useLayoutResolver, useLinkComponent, useListSlot, useMatch, useNavChromeBoundary, useNavVisible, useNavigate, useNavigationBlocker, usePageComponent, usePresentationCopy, useSidebar, useTheme, wrapperEnabled };
+export { ActionButton, type ActionButtonProps, type ActionItem, ActionOverflow, type ActionOverflowProps, type ActionSurface, AlertDialog, AlertDialogAction, AlertDialogActionProps, AlertDialogCancel, AlertDialogCancelProps, AlertDialogContent, AlertDialogContentProps, AlertDialogDescription, AlertDialogDescriptionProps, AlertDialogFooter, AlertDialogFooterProps, AlertDialogHeader, AlertDialogHeaderProps, AlertDialogOverlay, AlertDialogOverlayProps, AlertDialogPortal, AlertDialogTitle, AlertDialogTitleProps, AlertDialogTrigger, AppActions, AppFlowButton, type AppFlowButtonProps, AppHeader, type AppHeaderProps, AppLayout, type AppLayoutProps, AppShell, type AppShellProps, AppSidebar, type AppSidebarProps, AuthPage, type AuthPageProps, Avatar, AvatarFallback, AvatarImage, Badge, BadgeProps, BooleanDisplay, BooleanInput, BrandMark, Breadcrumbs, type BreadcrumbsProps, type BuildNavItemsArgs, BulkActionToolbar, type BulkActionToolbarProps, Button, ButtonProps, Card, CardContent, CardContentProps, CardDescription, CardDescriptionProps, CardFooter, CardFooterProps, CardHeader, CardHeaderProps, CardProps, CardTitle, CardTitleProps, CheckConfirmDialog, type CheckConfirmDialogProps, Checkbox, CheckboxProps, Collapsible, CollapsibleContent, CollapsibleTrigger, ColumnsToggle, Command, CommandDialog, CommandDialogProps, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandLoading, CommandLoadingProps, CommandPalette, CommandPaletteActionsGroup, type CommandPaletteActionsGroupProps, type CommandPaletteActionsTestIdRole, CommandPaletteCreateGroup, type CommandPaletteCreateGroupProps, type CommandPaletteCreateTestIdRole, CommandPaletteDocsGroup, type CommandPaletteDocsGroupProps, CommandPaletteNavigationGroups, type CommandPaletteNavigationGroupsProps, type CommandPaletteNavigationTestIdRole, type CommandPaletteProps, CommandPaletteRecentGroup, type CommandPaletteRecentGroupProps, type CommandPaletteRecentTestIdRole, CommandPaletteRecordsGroup, type CommandPaletteRecordsGroupProps, type CommandPaletteRecordsTestIdRole, type CommandPaletteTestIdRole, CommandPaletteTrigger, type CommandPaletteTriggerProps, CommandSeparator, ContextPicker, type ContextPickerProps, CopyId, CreateButton, type CreateButtonProps, CursorLoadMore, type CursorLoadMoreProps, DEFAULT_LANGUAGE, DEFAULT_LANGUAGE_STORAGE_KEY, DataTable, DataTableDateRangeFilter, type DataTableDateRangeFilterProps, DataTableEnumFilter, type DataTableEnumFilterProps, DataTableFacetedFilter, type DataTableFacetedFilterProps, DataTableNumRangeFilter, type DataTableNumRangeFilterProps, DataTableOperatorFilter, type DataTableOperatorFilterProps, type DataTableProps, DataTableRowActions, type DataTableRowActionsProps, DataTableTextFilter, type DataTableTextFilterProps, DataTableToolbar, type DataTableToolbarProps, DataTableViewOptions, type DataTableViewOptionsProps, DateDisplay, DateInput, DeclarativeDisplay, type DeclarativeDisplayProps, DeclarativeForm, type DeclarativeFormProps, type DeclarativeFormSlots, DefaultCommandPalette, type DefaultCommandPaletteProps, Dialog, DialogClose, DialogContent, DialogContentProps, DialogDescription, DialogDescriptionProps, type DialogFilterState, DialogFooter, DialogFooterProps, DialogHeader, DialogHeaderProps, DialogOverlayProps, DialogPresentationHost, DialogPresentationShell, DialogTitle, DialogTitleProps, DialogTrigger, DisabledAction, type DisabledActionProps, DocBrowser, type DocBrowserProps, DocInfo, type DocInfoProps, DocPanel, type DocPanelProps, DocTrailHelp, type DocTrailHelpProps, DocumentTitleProvider, type DraftRemovalSignal, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, ENUM_PICKER_CLEAR_SENTINEL, EditPageHeader, EnumBadge, type EnumBadgeProps, EnumDisplay, EnumInput, EnumPicker, type EnumPickerProps, type EnumPickerRenderAs, EnumDisplay$1 as EnumValueDisplay, type EnumDisplayProps as EnumValueDisplayProps, type EnumDisplayVariant as EnumValueDisplayVariant, ExportButton, type ExportButtonProps, ExportDialog, type ExportDialogProps, type FacetedFilterOption, Field, FieldDisplay, type FieldDisplayProps, type FieldProps, FileDisplay, FileField, type FileFieldProps, FileInput, type FileInputProps, FilterBadges, type FilterBadgesProps, FilterBuilder, type FilterBuilderProps, type FilterOperator, FilterPanel, type FilterPanelProps, FilterRegion, FilterValueControl, type FilterValueControlProps, FlowActionButton, type FlowActionButtonProps, Form, FormActions, FormControl, FormControlProps, FormDescription, FormDescriptionProps, FormField, FormItem, FormItemProps, FormLabel, FormLabelProps, FormMessage, FormMessageProps, HeaderBreadcrumbs, HelpButton, type HelpButtonProps, Icon, IconComponent, IconProps, Input, InputProps, Label, LabelProps, type LanguageCode, LanguageSubmenu, LanguageSwitch, type LanguageSwitchApi, type LanguageSwitchProps, type LinkComponent, type LinkComponentProps, LinkComponentProvider, type LinkComponentProviderProps, ListBody, ListBulkBar, type ListCellRenderer, ListColumns, ListControls, ListCreate, ListErrorState, type ListErrorStateProps, ListExport, ListFilters, ListFlows, ListLive, ListSavedViews, ListSearchInput, type ListSlot, type ListSlotRegion, type LoginCredentials, LoginForm, type LoginFormProps, NavAreaLayout, type NavAreaLayoutProps, NavAreaPage, NavChrome, NavChromeBoundaryProvider, type NavChromeProps, type NavItem, type NavLayout, type NavLayoutProps, NavMain, type NavMainProps, type NavTreeEntry, type NavTreeLayout, type NavTreeSection, NavigationGuardDialog, NumberDisplay, NumberInput, PACKAGE_NAME, PACKAGE_VERSION, type PageBreadcrumbsProps, PageHeader, type PageHeaderProps, type PaletteState, PinnedFilterControls, type PinnedFilterControlsProps, Popover, PopoverAnchor, PopoverClose, PopoverContent, PopoverContentProps, PopoverPresentationHost, PopoverTrigger, type PresentationCopy, Progress, ProgressProps, RecordActions, RecordBreadcrumbs, RecordPage, type RecordPageProps, RecordScreen, type RecordScreenProps, RecordTitle, RefreshButton, type RefreshButtonProps, RelationDisplay, RelationField, RelationManyDisplay, RelationPicker, LazyRelationPickerDialog as RelationPickerDialog, type RelationPickerDialogProps, RelationPickerInput, type RelationPickerProps, type ResolvedTheme, type ResourceBreadcrumbsProps, ResourceList, ResourceListPage, type ResourceListPageProps, type ResourceListProps, ResourcePageRouter, type ResourcePageRouterProps, type RowActionDescriptor, SavedViewsDropdown, type SavedViewsDropdownProps, type ScopeOption, ScopeSwitcher, type ScopeSwitcherProps, SecondarySidebarLayout, Select, SelectContent, SelectContentProps, SelectGroup, SelectItem, SelectItemProps, SelectLabel, SelectLabelProps, SelectScrollDownButton, SelectScrollDownButtonProps, SelectScrollUpButton, SelectScrollUpButtonProps, SelectSeparator, SelectSeparatorProps, SelectTrigger, SelectTriggerProps, SelectValue, Separator, Sheet, SheetClose, SheetContent, SheetContentProps, SheetDescription, SheetDescriptionProps, SheetFooter, SheetFooterProps, SheetHeader, SheetHeaderProps, SheetOverlayProps, SheetPresentationHost, SheetPresentationShell, SheetTitle, SheetTitleProps, SheetTrigger, type ShellBrand, type ShellContextValue, ShellProvider, type ShellProviderProps, type ShellUser, type ShellUserMapper, ShowPageHeader, Sidebar, SidebarBrand, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuButtonProps, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubButtonProps, SidebarMenuSubItem, SidebarProps, SidebarProvider, SidebarProviderProps, SidebarRail, SidebarSeparator, SidebarTrigger, Skeleton, type Slot, type SpacingKey, THEME_CHOICES, THEME_STORAGE_KEY, Table, TableBody, TableBodyProps, TableCaption, TableCaptionProps, TableCell, TableCellProps, TableHead, TableHeadProps, TableHeader, TableHeaderProps, TableProps, TableRow, TableRowProps, Tabs, TabsContent, TabsContentProps, TabsLayout, TabsList, TabsListProps, TabsTrigger, TabsTriggerProps, TaskRunPanel, TaskRunPanelProps, TextDisplay, TextInput, Textarea, TextareaDisplay, TextareaInput, TextareaProps, type ThemeChoice, ThemeSubmenu, ThemeToggle, Toaster, type ToasterProps, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TypographyKey, type UseBuroDataTableOptions, type UseDialogFilterStateOptions, type UseNavTreeOptions, type UseThemeResult, UserMenu, type UserMenuProps, badgeVariants, buildNavItems, buroSortingToTanStack, buttonVariants, cn, defaultNavLayouts, defaultUserMapper, downloadArtifact, formatOperatorLabel, hasIcon, i18nPrefixToRef, isImage, layoutSlot, listSlot, loadLanguage, loadLocale, localeLabel, modeForSurface, recordDisplayName, registerIcons, relationLinkClassName, resolveNavIcon, resolveUpdater, saveLanguage, saveLocale, shadcnBlockImplementations, shadcnFieldImplementations, shadcnPresentationHosts, spacing, tanStackSortingToBuro, toast, typography, useBuroDataTable, useCurrentUser, useDialogFilterState, useDocumentTitle, useExportRunWatcher, useFormControl, useFormField, useHref, useIsMobile, useLanguagePaletteActions, useLanguageSwitch, useLayout, useLayoutResolver, useLinkComponent, useListSlot, useMatch, useNavChromeBoundary, useNavIcon, useNavTree, useNavVisible, useOptionalSidebar, usePaletteState, usePresentationCopy, useShell, useSidebar, useTheme, useThemePaletteActions, wrapperEnabled };
 //# sourceMappingURL=index.d.ts.map