@burojs/react 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 
-import { Action, ActionDI, ActionDataAccess, ActionResult, AppContext, AppDefinition, AppRuntime, ApplicationSnapshot, Audit, AuditFieldDiff, AuthCheckResult, AuthProvider, AuthResult, Availability, BatchedQueryOperation, BulkActionHandler, BulkTarget, Capability, CapabilityDecision, Check, CheckOutcome, CheckSurface, CountDescriptor, CountPolicy, CreateManyDescriptor, CreateOneDescriptor, CustomMutationHandle, CustomQueryHandle, DataError, DataProvider, DataProviderSessionSnapshot, DataQueryKey, DataSessionController, DataSessionController as DataSessionController$1, DataSessionSnapshot, DataSessionState, DataSessionTransitionParticipant, DataSessionTransitionParticipant as DataSessionTransitionParticipant$1, DeleteManyDescriptor, DeleteOneDescriptor, Dispatcher, DocContent, DocsConfig, DocumentTemplate, EntityRef, EnumValue, ErasedMutationDescriptor, ErasedQueryDescriptor, ErasedResourceHandle, ExportFormat, ExportHandle, ExportRequest, Exporter, FieldContextFrames, FieldDeclaration, FieldDefBase, FieldIssue, FieldOption, FilterExpression, FilterGroup, FilterPredicateOp, FixedFilterInput, I18nCaps, InferCreateInput, InferCustomInput, InferCustomOutput, InferUpdateInput, ItemActionPlacement, LayerRuntime, LayerStatus, ListDescriptor, LivePlan, ManifestResolution, ManyDescriptor, MessageReference, MutationResultFor, OneDescriptor, PermissionMap, PortableObject, PortableProjection, PortableSnapshotManifest, PortableValue, QueryContext, QueryResultFor, RecordCodecError, RecordCodecOutcome, RegistryResource, RequestContext, ResolvedDocTopic, ResolvedFixedFilter, ResourceDef, ResourceFieldDefinition, ResourceFieldMap, ResourceHandle, ResourceRecordCodec, ResourceRefInput, RuleContext, SavedViewDef, SnapshotEntityTargetInput, SortExpression, StandardSchemaV1, TaskRunFailure, TaskRunReport, UIActivationContext, UIActivationSurface, UIPresentRequest, UIPresentResult, UIPresentationDescriptor, UIPresentationRuntime, UiSettingCardinality, UiSettingCollection, UiSettingEntryPermissions, UiSettingScope, UiSettingSingleton, UiSettingTypeDefinition, UiSettingsAdapter, UiSettingsIssue, UiSettingsSnapshot, UiSettingsStore, UpdateManyDescriptor, UpdateOneDescriptor, ValidationContext, ValidationIssueSeverity, ValidationIssues, createDataSession, createResourceRecordCodec, normalizeServerRecordIssues } from "@burojs/core";
+import { _ as InlineFlowHolder, a as FormSubmitResult, c as FieldBinding, d as ResolvedIssue, f as CheckGateRequest, g as PlacementRuntime, h as useCheckGate, i as FormSteps, l as FormValues, m as UseCheckGateResult, n as FormControllerFailure, o as UseFormControllerFormOptions, p as CheckGateState, r as FormDraftState, s as UseFormControllerRecordOptions, t as FormController, u as RelationFilterOpt, v as InlineLease } from "./types-DH3beUOO.js";
+import { ActionDI, ActionDataAccess, ActionFlow, AnyFrameHandle, AppAuditEventInput, AppContext, AppDefinition, AppRuntime, ApplicationSnapshot, Audit, AuthCheckResult, AuthProvider, AuthResult, Availability, BatchedQueryOperation, BlockLookup, BulkTarget, Capability, CapabilityDecision, CheckOutcome, CheckSurface, CompiledFlow, CompiledScreen, CountDescriptor, CountPolicy, CreateOneDescriptor, CustomMutationHandle, CustomQueryHandle, DataError, DataProvider, DataProviderSessionSnapshot, DataQueryKey, DataSessionController, DataSessionController as DataSessionController$1, DataSessionSnapshot, DataSessionState, DataSessionTransitionParticipant, DataSessionTransitionParticipant as DataSessionTransitionParticipant$1, DeleteManyDescriptor, DeleteOneDescriptor, Dispatcher, DispatcherEffects, DocContent, DocsConfig, EntityRef, EnumValue, ErasedMutationDescriptor, ErasedQueryDescriptor, ErasedResourceHandle, ExportFormat, ExportHandle, ExportRequest, Exporter, FieldAccessMap, FieldContextSources, FieldDeclaration, FieldDefBase, FieldOption, FieldReach, FilterExpression, FilterGroup, FilterPredicateOp, FixedFilterInput, FlowControlState, FlowGateAnswer, FlowRef, FlowResult, FlowRun, FlowTarget, FrameHandle, FrameKind, I18nCaps, InferBlockData, InferBlockProps, InferCreateInput, InferCustomInput, InferCustomOutput, InferSchemaOutput, InferUpdateInput, ItemActionPlacement, LayerRuntime, LayerStatus, LayoutSize, ListAccess, ListDescriptor, LivePlan, ManifestResolution, ManyDescriptor, MutationResultFor, NodeState, OneDescriptor, PageRequires, PanelTone, PermissionMap, PlanScreenInput, PortableObject, PortableProjection, PortableSnapshotManifest, PortableValue, QueryContext, QueryResultFor, QuickHost, RecordCodecError, RecordCodecOutcome, RegistryReader, RegistryResource, RelationCandidate, RequestContext, ResolvedDocTopic, ResolvedFixedFilter, ResourceDef, ResourceFieldMap, ResourceHandle, ResourceRecordCodec, ResourceRefInput, RouteDescriptor as RouteDescriptor$1, Row, RuleContext, SavedViewDef, ScreenMode, ScreenPlan, ScreenSources, SearchDecl, SlotMap, SnapshotEntityTargetInput, SortExpression, SourceState, StandardSchemaV1, TaskRunFailure, TaskRunReport, UIActivationContext, UIActivationSurface, UIPresentAnchor, UIPresentHost, UIPresentRequest, UIPresentResult, UIPresentationRuntime, UiSettingCardinality, UiSettingCollection, UiSettingEntryPermissions, UiSettingScope, UiSettingSingleton, UiSettingTypeDefinition, UiSettingsAdapter, UiSettingsIssue, UiSettingsSnapshot, UiSettingsStore, UpdateManyDescriptor, UpdateOneDescriptor, ValidationIssue, ValidationIssues, createDataSession, createResourceRecordCodec, normalizeServerRecordIssues } from "@burojs/core";
 import * as React from "react";
-import { ComponentType, ReactElement, ReactNode } from "react";
+import { ComponentType, Context, ReactElement, ReactNode, RefObject } from "react";
 import { Query, QueryClient, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
 import { I18nFacade, ResourceI18n } from "@burojs/i18n-core";
 import { FileRef, FileStorageAdapter, ResolveCtx } from "@burojs/file-storage";
@@ -72,6 +73,75 @@ interface LiveCoordinator {
   dispose(): Promise<void>;
 }
 //#endregion
+//#region src/data/live/query-live-observer.d.ts
+interface QueryLiveObserverState {
+  readonly live: LiveState;
+  /** Only observer-detected protocol violations synthesize query failure. */
+  readonly protocolError?: DataError;
+}
+/**
+ * Reduces a descriptor's shared live lease into its canonical TanStack cache
+ * entry. It owns no provider resources beyond its lease and becomes inert as
+ * soon as that lease is released, which prevents retired session work from
+ * writing into a replacement cache partition.
+ */
+declare class QueryLiveObserver<T extends ErasedQueryDescriptor = ErasedQueryDescriptor> {
+  #private;
+  readonly identity: string;
+  constructor(args: {
+    readonly descriptor: T;
+    readonly runtime: DataRuntimeContextValue;
+    readonly queryClient: QueryClient;
+  });
+  getState: () => QueryLiveObserverState;
+  subscribe: (listener: () => void) => (() => void);
+  /** Whether a regular query should execute after the selected live plan is ready. */
+  get queryEnabled(): boolean;
+  execute(signal: AbortSignal): Promise<QueryResultFor<T>>;
+  dispose(): void;
+}
+//#endregion
+//#region src/data/live/live-queries.d.ts
+/** One consumer's hold on the shared observer of a descriptor. */
+interface LiveQueryRetention {
+  readonly observer: QueryLiveObserver;
+  /** Drops this hold. Idempotent; the last release disposes the observer. */
+  release(): void;
+}
+/**
+ * The runtime's one `QueryLiveObserver` per descriptor identity and session
+ * generation, shared by every mounted consumer of that descriptor and kept
+ * alive while any of them retains it. Invariant: `queryFn` resolves the
+ * observer when the request runs, never when the options were built, because
+ * TanStack runs the `queryFn` of whichever consumer rendered last.
+ */
+interface LiveQueryRegistry {
+  /**
+   * Retains the shared observer for `descriptor` at the current session
+   * generation, creating it (and acquiring its live lease) on the first hold.
+   * Call it from a committed effect, and only for an enabled query.
+   */
+  retain(descriptor: ErasedQueryDescriptor): LiveQueryRetention;
+  /**
+   * The TanStack `queryFn` for `descriptor`. It executes through the retained
+   * observer of the current generation when a consumer holds one, and falls
+   * back to a plain `executeQuery` when none does (a disabled query's manual
+   * `refetch()`, for instance).
+   *
+   * During a session-generation change there is a short window between the
+   * old observer retiring and the consumer's effect retaining the new one; a
+   * request started there also takes the fallback. That is harmless: the
+   * transition's own `cancelQueries()` cancels it, or its `clear()` has
+   * already detached the query it would write to, and the re-retained
+   * observer runs the next generation's first fetch itself.
+   */
+  queryFn(descriptor: ErasedQueryDescriptor): (context: {
+    readonly signal: AbortSignal;
+  }) => Promise<unknown>;
+  /** Number of live entries, for diagnostics and tests. */
+  readonly size: number;
+}
+//#endregion
 //#region src/data/provider-registry.d.ts
 interface ProviderServiceRef {
   readonly id: string;
@@ -96,6 +166,13 @@ interface DataRuntimeContextValue {
   readonly providers: DataProviderRegistry;
   readonly batchCoordinator: BatchCoordinator;
   readonly liveCoordinator: LiveCoordinator;
+  /**
+   * One shared live query observer per descriptor and session generation,
+   * retained by the query hooks.
+   *
+   * @internal
+   */
+  readonly liveQueries: LiveQueryRegistry;
   readonly liveSetupTimeoutMs: number;
   /** Present only in React trees configured with a native AuthProvider. */
   readonly authController?: AuthController;
@@ -215,6 +292,10 @@ declare function useIsAuthenticated(): UseQueryResult<AuthCheckResult, DataError
 declare function useLogin(): UseMutationResult<AuthResult, DataError, unknown>;
 declare function useLogout(): UseMutationResult<AuthResult, DataError, unknown>;
 //#endregion
+//#region src/auth/context.d.ts
+/** The auth controller, or `null` when `BuroProvider` has no `authProvider`. Never throws. */
+declare function useOptionalAuthController(): AuthController | null;
+//#endregion
 //#region src/hooks/data/use-query-descriptor.d.ts
 type NativeQueryOptions<TData, TSelected = TData> = Omit<UseQueryOptions<TData, DataError, TSelected, DataQueryKey>, 'queryKey' | 'queryFn' | 'placeholderData' | 'refetchInterval'> & {
   /**
@@ -259,6 +340,14 @@ type UseOneOptions<R extends AnyResource$6, TSelected = QueryResultFor<OneDescri
 declare function useOne<R extends AnyResource$6, TSelected = QueryResultFor<OneDescriptor<R>>>(resource: R, options: UseOneOptions<R, TSelected>): NativeQueryResult<QueryResultFor<OneDescriptor<R>>, TSelected>;
 declare function useOne<TSelected = QueryResultFor<OneDescriptor<ErasedResourceHandle>>>(resource: string, options: UseOneOptions<ErasedResourceHandle, TSelected>): NativeQueryResult<QueryResultFor<OneDescriptor<ErasedResourceHandle>>, TSelected>;
 //#endregion
+//#region src/hooks/data/retry-record-read.d.ts
+/**
+ * Record reads retry only what the provider called retryable, at most twice.
+ * TanStack's default — three retries, about seven seconds before an error
+ * shows — would also retry a `not-found` or a `forbidden` that cannot succeed.
+ */
+declare function retryRecordRead(failureCount: number, error: DataError): boolean;
+//#endregion
 //#region src/hooks/data/use-many.d.ts
 type AnyResource$5 = ResourceHandle<unknown, Record<string, FieldDefBase>, string, string>;
 type UseManyOptions<R extends AnyResource$5, TSelected = QueryResultFor<ManyDescriptor<R>>> = {
@@ -369,23 +458,12 @@ type UseCreateOneOptions<R extends AnyResource$2> = NativeMutationOptions<Mutati
 }> & {
   readonly providerOptionsOverride?: PortableObject;
 };
-type UseCreateManyOptions<R extends AnyResource$2> = NativeMutationOptions<MutationResultFor<CreateManyDescriptor<R>>, {
-  readonly values: readonly InferCreateInput<R>[];
-}> & {
-  readonly providerOptionsOverride?: PortableObject;
-};
 declare function useCreateOne<R extends AnyResource$2>(resource: R, options?: UseCreateOneOptions<R>): UseMutationResult<MutationResultFor<CreateOneDescriptor<R>>, DataError, {
   readonly values: InferCreateInput<R>;
 }>;
 declare function useCreateOne(resource: string, options?: UseCreateOneOptions<ErasedResourceHandle>): UseMutationResult<MutationResultFor<CreateOneDescriptor<ErasedResourceHandle>>, DataError, {
   readonly values: unknown;
 }>;
-declare function useCreateMany<R extends AnyResource$2>(resource: R, options?: UseCreateManyOptions<R>): UseMutationResult<MutationResultFor<CreateManyDescriptor<R>>, DataError, {
-  readonly values: readonly InferCreateInput<R>[];
-}>;
-declare function useCreateMany(resource: string, options?: UseCreateManyOptions<ErasedResourceHandle>): UseMutationResult<MutationResultFor<CreateManyDescriptor<ErasedResourceHandle>>, DataError, {
-  readonly values: readonly unknown[];
-}>;
 //#endregion
 //#region src/hooks/data/use-update.d.ts
 type AnyResource$1 = ResourceHandle<any, Record<string, FieldDefBase>, string, string>;
@@ -434,6 +512,258 @@ type UseCustomMutationOptions<TInput, TOutput> = NativeMutationOptions<TOutput,
 /** Resolves a trusted custom mutation and its declaration-owned effects. */
 declare function useCustomMutation<THandle extends CustomMutationHandle<unknown, unknown>>(handle: THandle, options?: UseCustomMutationOptions<InferCustomInput<THandle>, InferCustomOutput<THandle>>): UseMutationResult<InferCustomOutput<THandle>, DataError, InferCustomInput<THandle>>;
 //#endregion
+//#region src/frames/view-props.d.ts
+/** Reads `frames.<id>.<key>` (the block convention, foundation 12). */
+type FrameTranslate = (key: string, options?: {
+  readonly params?: Record<string, unknown>;
+  readonly count?: number;
+}) => string;
+/**
+ * The attributes of the styling contract a node frame spreads on its root: `data-buro-node`,
+ * `data-buro-key`, `data-buro-tone`, `data-buro-state` (spec 3.5).
+ */
+type FrameNodeAttributes = Readonly<Record<`data-buro-${string}`, string>>;
+/** The slots a record frame view receives: `body` always rendered, every other slot or `null`. */
+type RecordFrameSlots<S extends SlotMap> = {
+  readonly body: ReactElement;
+} & { readonly [K in Exclude<keyof S & string, 'body'>]: ReactElement | null; };
+/** What a record frame's view is rendered with (spec 3.3). */
+interface RecordFrameViewProps<F extends AnyFrameHandle = FrameHandle<'record'>> {
+  /**
+   * Each slot's planned tree inside its framework wrapper; `null` when the slot is optional and
+   * omitted, absent in this mode (create) or planned empty. `body` holds the form in edit and
+   * create.
+   */
+  readonly slots: RecordFrameSlots<F['slots']>;
+  readonly host: 'page' | 'sheet' | 'dialog';
+  readonly mode: 'show' | 'edit' | 'create';
+  readonly screen: {
+    readonly resource: string;
+    readonly entry: 'route' | 'quick';
+  };
+  /** The screen's record as the user may see it; `undefined` before it is read and in create. */
+  readonly record: Readonly<Record<string, unknown>> | undefined;
+  readonly t: FrameTranslate;
+}
+/** What a peek frame's view is rendered with (spec 3.9). */
+interface PeekFrameViewProps<F extends AnyFrameHandle = FrameHandle<'peek'>> {
+  readonly slots: { readonly [K in keyof F['slots'] & string]: ReactElement | null; };
+  /** The one row the peek read, filtered as the peek shows it. */
+  readonly record: Readonly<Record<string, unknown>>;
+  /** Opens the record's `quick.show` through the entry gate (the title click). */
+  open(): void;
+  readonly t: FrameTranslate;
+}
+/**
+ * What a list frame's view is rendered with (P7-34): the planned trees of its slots (`null` when a
+ * slot is omitted or planned empty) and the resource's registry name. The rows are not a prop: a
+ * frame arranges the framework's pieces (`<ListControls/>`, `<ListBody/>`, …), which read the list
+ * controller the framework owns outside the frame.
+ */
+interface ListFrameViewProps<F extends AnyFrameHandle = FrameHandle<'list'>> {
+  readonly slots: { readonly [K in keyof F['slots'] & string]: ReactElement | null; };
+  readonly resource: string;
+  readonly t: FrameTranslate;
+}
+/**
+ * What a page frame's view is rendered with (P7 3.14): the page's slots as rendered elements
+ * (`body` always), the page label and its parsed `route` params. The framework owns the page's
+ * `<h1>`, its access gate and `NavChrome`; the view arranges the slots inside the page body and
+ * renders no heading of its own.
+ */
+interface PageFrameViewProps<F extends AnyFrameHandle = FrameHandle<'page'>> {
+  readonly slots: { readonly [K in keyof F['slots'] & string]: ReactElement | null; };
+  /** The page's label, resolved (the framework draws it as the `<h1>`). */
+  readonly label: string;
+  /** The page's parsed params: the same values `l.ref('route', …)` reads. */
+  readonly params: Readonly<Record<string, unknown>>;
+  readonly t: FrameTranslate;
+}
+/** What a panel frame's view is rendered with (spec 3.5). */
+interface PanelFrameViewProps {
+  /**
+   * The panel's content inside the framework's body element; `null` when closed. While pending,
+   * the framework's skeleton.
+   */
+  readonly body: ReactElement | null;
+  readonly title?: string;
+  readonly description?: string;
+  readonly tone?: PanelTone;
+  readonly icon?: string;
+  readonly collapsible: boolean;
+  readonly open: boolean;
+  /** Opens or closes a collapsible panel; the engine calls the same function to reveal an error. */
+  onToggle(next: boolean): void;
+  readonly errorCount: number;
+  readonly mode: ScreenMode;
+  /** The id to put on the title element: the body is labelled by it. */
+  readonly titleId: string;
+  /** The id of the framework's body element, for the toggle's `aria-controls`. */
+  readonly bodyId: string;
+  /** The node's «i», or `null`. */
+  readonly info: ReactElement | null;
+  readonly nodeAttributes: FrameNodeAttributes;
+  readonly t: FrameTranslate;
+}
+/** One tab of a tabs frame. */
+interface FrameTab {
+  readonly key: string;
+  readonly title: string;
+  readonly errorCount: number;
+  /** Only the active tab's panel is rendered (demand is the planner's). */
+  readonly panel: ReactElement | null;
+}
+/** What a tabs frame's view is rendered with (spec 3.5). */
+interface TabsFrameViewProps {
+  readonly tabs: readonly FrameTab[];
+  readonly active: string;
+  onSelect(key: string): void;
+  readonly info: ReactElement | null;
+  readonly nodeAttributes: FrameNodeAttributes;
+  readonly t: FrameTranslate;
+}
+/** One step of a steps frame. */
+interface FrameStep {
+  readonly key: string;
+  readonly title: string;
+  readonly errorCount: number;
+  readonly state: 'current' | 'complete' | 'reachable' | 'locked';
+  /**
+   * Outside a wizard, every step's whole panel; inside, the current step's body only (the frame
+   * draws its heading), `null` for the others.
+   */
+  readonly panel: ReactElement | null;
+  readonly description?: string;
+  /** The id to put on the step's heading: the step's body is labelled by it. */
+  readonly titleId: string;
+  /** The step panel's «i», or `null`. */
+  readonly info: ReactElement | null;
+  /** The step panel's styling attributes (`data-buro-node="panel"`, its key, tone and state). */
+  readonly nodeAttributes: FrameNodeAttributes;
+}
+/** What a steps frame's view is rendered with (spec 3.5). */
+interface StepsFrameViewProps {
+  /** A create whose root is this steps node: one step at a time. */
+  readonly wizard: boolean;
+  readonly steps: readonly FrameStep[];
+  readonly current: string;
+  goTo(key: string): void;
+  back(): void;
+  /** Validates the current step, then moves on. */
+  next(): void;
+  /** Attach to the current step's heading: the framework focuses it when the step changes. */
+  readonly headingRef: RefObject<HTMLElement | null>;
+  readonly info: ReactElement | null;
+  readonly nodeAttributes: FrameNodeAttributes;
+  readonly t: FrameTranslate;
+}
+/** The props a frame's view receives, by the frame's kind. */
+type FrameViewProps<F extends AnyFrameHandle = AnyFrameHandle> = F['for'] extends 'record' ? RecordFrameViewProps<F> : F['for'] extends 'peek' ? PeekFrameViewProps<F> : F['for'] extends 'list' ? ListFrameViewProps<F> : F['for'] extends 'page' ? PageFrameViewProps<F> : F['for'] extends 'panel' ? PanelFrameViewProps : F['for'] extends 'tabs' ? TabsFrameViewProps : F['for'] extends 'steps' ? StepsFrameViewProps : never;
+//#endregion
+//#region src/frames/implementation.d.ts
+/**
+ * A frame's view, registered in `<BuroProvider frameImplementations>` (spec 3.2). Without a type
+ * argument, the view of any frame.
+ */
+interface FrameImplementation<F extends AnyFrameHandle = any> {
+  /** `<namespace>:<name>`. */
+  readonly id: string;
+  readonly frame: EntityRef;
+  readonly for: FrameKind;
+  /** The frame handle `implementFrame` was given. */
+  readonly definition: F;
+  readonly component?: ComponentType<FrameViewProps<F>>;
+  readonly load?: () => Promise<{
+    readonly default: ComponentType<FrameViewProps<F>>;
+  }>;
+}
+/** The app's frame views, keyed by frame id. */
+type FrameImplementationCatalog = Readonly<Record<string, FrameImplementation<any>>>;
+/**
+ * The view of a frame: `component`, or `load` (a module whose default export is the view,
+ * requested when a screen first renders it). Register the result through
+ * `composeFrameImplementations` on `<BuroProvider frameImplementations>`.
+ *
+ * @throws TypeError when `frame` is not a frame handle, or when both or neither of `load` and
+ * `component` are given.
+ */
+declare function implementFrame<F extends AnyFrameHandle>(frame: F, impl: {
+  readonly component: ComponentType<FrameViewProps<F>>;
+  readonly load?: never;
+} | {
+  readonly load: NonNullable<FrameImplementation<F>['load']>;
+  readonly component?: never;
+}): FrameImplementation<F>;
+/**
+ * The app's frame views as one catalogue, keyed by frame id: takes `implementFrame` results.
+ * A duplicate id is a development error and the later entry wins; an entry for a built-in
+ * (`buro:`) frame is a development error and is dropped — the app's default frame is chosen in
+ * `defineAppDefinition({ frames })`, never by replacing a built-in view (P6-9).
+ *
+ * @throws TypeError for an argument that is not an `implementFrame` result.
+ */
+declare function composeFrameImplementations(...entries: readonly FrameImplementation<any>[]): FrameImplementationCatalog;
+//#endregion
+//#region src/blocks/implementation.d.ts
+/** Whether a prop of `B` is a `block()` prop, by its schema's output. */
+type IsBlockProp<O> = O extends {
+  readonly block: EntityRef;
+} ? true : false;
+/**
+ * The props a block view receives: each prop's schema output, a `block()` prop as the rendered
+ * nested placement (`ReactElement`, `ReactElement[]` for a list).
+ */
+type BlockViewPropValues<B> = { [K in keyof InferBlockProps<B>]: InferBlockProps<B>[K] extends readonly (infer E)[] ? IsBlockProp<E> extends true ? readonly ReactElement[] : InferBlockProps<B>[K] : IsBlockProp<InferBlockProps<B>[K]> extends true ? ReactElement : InferBlockProps<B>[K]; };
+/** The names of a block's `data` entries. */
+type BlockDataEntryName<B> = keyof InferBlockData<B> & string;
+/** What a block view is rendered with (spec 8.2). */
+interface BlockViewProps<B> {
+  /** Each prop's schema output; a `block()` prop is the nested placement, rendered. */
+  readonly props: BlockViewPropValues<B>;
+  /** Ready values only: the framework chrome draws pending, failed and absent. */
+  readonly data: Readonly<Record<BlockDataEntryName<B>, unknown>>;
+  /** Reads `blocks.<id>.<key>`. */
+  readonly t: (key: string, options?: {
+    readonly params?: Record<string, unknown>;
+    readonly count?: number;
+  }) => string;
+}
+/** A block's view, registered in `<BuroProvider blockImplementations>` (spec 8.2). */
+interface BlockImplementation<B = unknown> {
+  /** `<namespace>:<name>`. */
+  readonly id: string;
+  readonly block: EntityRef;
+  /** The block handle `implementBlock` was given (`renderBlock` validates props through it). */
+  readonly definition: B;
+  readonly load?: () => Promise<{
+    readonly default: ComponentType<BlockViewProps<B>>;
+  }>;
+  readonly component?: ComponentType<BlockViewProps<B>>;
+}
+type BlockImplementationCatalog = Readonly<Record<string, BlockImplementation<any>>>;
+/**
+ * The view of a block: `load` (a module whose default export is the view, requested only when a
+ * placement mounts) or `component`. Register the result through `composeBlockImplementations`
+ * on `<BuroProvider blockImplementations>`.
+ *
+ * @throws TypeError when `block` is not a block handle, or when both or neither of `load` and
+ * `component` are given.
+ */
+declare function implementBlock<B>(block: B, impl: {
+  readonly load: NonNullable<BlockImplementation<B>['load']>;
+  readonly component?: never;
+} | {
+  readonly component: ComponentType<BlockViewProps<B>>;
+  readonly load?: never;
+}): BlockImplementation<B>;
+/**
+ * The app's block views as one catalogue, keyed by block id: takes `implementBlock` results (not
+ * records). A duplicate id is a development error and the later entry wins.
+ *
+ * @throws TypeError for an argument that is not an `implementBlock` result.
+ */
+declare function composeBlockImplementations(...entries: readonly BlockImplementation<any>[]): BlockImplementationCatalog;
+//#endregion
 //#region src/fields/types.d.ts
 /** The render surface requested by a field consumer. */
 type FieldRenderSurface = 'input' | 'display';
@@ -475,7 +805,8 @@ interface FieldTestIds {
  * domain format.
  */
 interface FieldImplementationLayout {
-  readonly fullWidth?: boolean;
+  /** The default width of a field this implementation renders (`ui.size` wins). */
+  readonly size?: LayoutSize;
 }
 /** Locale-aware, renderer-safe access to the active application content model. */
 interface FieldI18n extends I18nCaps {
@@ -498,7 +829,12 @@ interface FieldRenderContext<TMeta extends Readonly<Record<string, unknown>> = R
   readonly ui: FieldUiHints;
   readonly options: readonly FieldOption[];
   readonly i18n: FieldI18n;
-  readonly frames: FieldContextFrames;
+  /**
+   * What a portable condition reads against: the record, the values and the
+   * app scope. On an input surface `values` are the live form values; on a
+   * display surface there is no form, so `values` is the record itself.
+   */
+  readonly sources: FieldContextSources;
   readonly pending: boolean;
   readonly touched: boolean;
   readonly issues: ValidationIssues;
@@ -536,6 +872,13 @@ interface FieldImplementation<T, TMeta extends Readonly<Record<string, unknown>>
   readonly CollectionInput?: ComponentType<CollectionInputProps<T, TMeta>>;
   readonly CollectionDisplay?: ComponentType<CollectionDisplayProps<T, TMeta>>;
   readonly layout?: FieldImplementationLayout;
+  /**
+   * The schema of the `meta` this implementation reads (P7 3.3): applied to the resolved `meta`
+   * (refs read) at render, so `props.meta` is the schema's output. A refusal renders the field
+   * misconfigured and blocks submit; `checkApp({ fieldImplementations })` checks literal metas
+   * ahead of time. Without one, the implementation receives the resolved record untyped.
+   */
+  readonly meta?: StandardSchemaV1<unknown, TMeta>;
 }
 type FieldImplementationComponent = ComponentType<ScalarInputProps<unknown>> | ComponentType<ScalarDisplayProps<unknown>> | ComponentType<CollectionInputProps<unknown>> | ComponentType<CollectionDisplayProps<unknown>>;
 type FieldImplementationSource = 'explicit' | 'format' | 'collection-format' | 'array-shell' | 'base' | 'fallback';
@@ -560,6 +903,8 @@ interface FieldImplementationDiagnostic {
 }
 interface ResolvedFieldImplementation {
   readonly Component?: FieldImplementationComponent;
+  /** The catalogue entry the field resolved to (its `meta` schema, P7 3.3); absent on a fallback. */
+  readonly implementation?: FieldImplementation<any, any>;
   readonly multiple: boolean;
   readonly source: FieldImplementationSource;
   readonly layout: FieldImplementationLayout;
@@ -693,30 +1038,57 @@ declare function UIInstanceProvider({ instance, presentation, children }: {
   readonly children: ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
 //#endregion
-//#region src/ui/use-ui-present.d.ts
-/**
- * Reads the current activation: the surface from the nearest
- * `UIActivationSurfaceProvider` (defaulting to `{ type: 'global' }` when
- * there isn't one) plus a live snapshot of the app's resolver slices, if a
- * `BuroProvider` is mounted above. Outside one, `slices` is `{}` — this
- * hook (and `useUIPresent`, which is built on it) works standalone, e.g. in
- * a unit test that only wires up `UIPresentationRuntimeProvider`.
- */
-declare function useCurrentUIActivation(): UIActivationContext;
-/** An imperative present request; `activation` is captured automatically and need not (usually) be supplied. */
-type UIPresentInput = Omit<UIPresentRequest, 'activation'> & {
-  readonly activation?: Partial<UIActivationContext>;
-};
-type UIPresent = (request: UIPresentInput) => UIPresentResult;
-/**
- * Returns a `present` function that captures the current activation
- * (surface + resolver slices) at call time and forwards the request to the
- * `UIPresentationRuntime` supplied by the nearest `UIPresentationRuntimeProvider`.
- * A caller may override `surface` and/or `slices` explicitly via the
- * `activation` field of the request; anything left unset falls back to the
- * captured activation.
- */
-declare function useUIPresent(): UIPresent;
+//#region src/quick/quick-stack.d.ts
+/** One entry of a quick overlay: a record's quick screen in a mode. */
+interface QuickEntry {
+  readonly resource: string;
+  readonly mode: 'show' | 'edit' | 'create';
+  /** The record of `show` and `edit`; absent on `create`. */
+  readonly recordId?: string;
+  /** `create`'s trusted defaults (the caller's tier, P1b+P1c decision 7). */
+  readonly defaults?: Readonly<Record<string, unknown>>;
+  /**
+   * `create`'s user input (a search text typed into a relation select): form values the user can
+   * see and change, applied once to the fields the plan holds `active`, never a trusted default
+   * (P6 plan ruling 7).
+   */
+  readonly input?: Readonly<Record<string, unknown>>;
+  /** The entry's record title once its screen has read it: what "Back to …" names. */
+  readonly title?: string;
+}
+/** A created row, or `null`: what `useQuick().create` resolves with. */
+type QuickSettledRow = Readonly<Record<string, unknown>> | null;
+/**
+ * The history of one quick overlay (spec 4.9): a stack of entries of which only the top is
+ * mounted. A relation inside a sheet pushes; Back pops; Edit in `quick.show` replaces the top.
+ * The history is never in the URL. An external store: `subscribe` / `getSnapshot` for
+ * `useSyncExternalStore`, and `getSnapshot()` changes identity on every change.
+ *
+ * `settled` resolves once, with the row a `quick.create` saved or `null` when the overlay closed
+ * without one.
+ */
+declare class QuickStack {
+  private stack;
+  private readonly listeners;
+  private resolveSettled;
+  private isSettled;
+  readonly settled: Promise<QuickSettledRow>;
+  constructor(first: QuickEntry);
+  get entries(): readonly QuickEntry[];
+  get top(): QuickEntry;
+  push(entry: QuickEntry): void;
+  /** Back: drops the top entry. A stack of one is never emptied (closing is the overlay's). */
+  pop(): void;
+  /** Switches the top entry in place (Edit ↔ show), keeping the depth. */
+  replaceTop(entry: QuickEntry): void;
+  /** Records the top entry's title once its record is read. */
+  nameTop(title: string): void;
+  /** Resolve `settled`, once: later calls change nothing. */
+  settle(row: QuickSettledRow): void;
+  subscribe: (listener: () => void) => (() => void);
+  getSnapshot: () => readonly QuickEntry[];
+  private publish;
+}
 //#endregion
 //#region src/ui/ui-presentations.d.ts
 /**
@@ -731,6 +1103,93 @@ interface UIPresentationHostProps {
   readonly component: ComponentType<Record<string, unknown>>;
   readonly props: Readonly<Record<string, unknown>>;
   readonly options: Readonly<Record<string, unknown>>;
+  /** A popover's anchor, passed through by reference (`host: 'popover'` only). */
+  readonly anchor?: UIPresentAnchor;
+}
+/** The reserved component key of a quick entry: resolved from `presentationHosts.screens.quick`. */
+declare const QUICK_COMPONENT = "buro:quick";
+/** The reserved component key of a peek: resolved from `presentationHosts.screens.peek`. */
+declare const PEEK_COMPONENT = "buro:peek";
+/** The reserved component key of a flow's host: resolved from `presentationHosts.screens.flow`. */
+declare const FLOW_COMPONENT = "buro:flow";
+/** The reserved component key of a modal action's block: resolved from `presentationHosts.screens.block`. */
+declare const BLOCK_COMPONENT = "buro:block";
+/**
+ * What the block screen receives (P7 3.16): the block a modal action presents and its portable
+ * props. For an item action the clicked row and its resource ride along: the screen reads the row
+ * projected by field view, binds `ref('record', …)` from it, and draws nothing until that is decided.
+ */
+interface BlockScreenProps {
+  readonly block: {
+    readonly namespace: string;
+    readonly id: string;
+  };
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly resource?: string;
+  readonly record?: Row;
+  readonly label?: string;
+}
+/** What the quick screen receives: the overlay's history, whose top entry it renders. */
+interface QuickScreenProps {
+  readonly stack: QuickStack;
+}
+/** What the peek screen receives: the target and the key it previews. */
+interface PeekScreenProps {
+  readonly target: string;
+  readonly id?: string;
+  readonly by?: {
+    readonly field: string;
+    readonly key: string;
+  };
+}
+/** A flow the host starts itself (P4-C review I1): what to run, on what. */
+interface FlowStart {
+  readonly target: FlowRef | FlowTarget;
+  readonly record?: Row;
+  readonly args?: Row;
+  readonly selection?: {
+    readonly ids: readonly string[];
+    readonly count: number;
+  };
+}
+/**
+ * What a flow's host screen receives (P4 spec 4.15). Either a run its opener holds (`run` and
+ * `compiled`: a `{ label, submit }` flow's outcome, drawn in a dialog), or a flow to start
+ * (`start`): the host then owns the run, so the host outlives its opener — a row that left the
+ * page, a menu item that closed — and its form, its draft and a pending write with it. `then`
+ * runs through the opener's dispatcher scope (`effects`) after the host closed; `onSettle`
+ * reports each outcome to the opener.
+ */
+interface FlowScreenProps {
+  readonly run?: FlowRun;
+  readonly start?: FlowStart;
+  /** `'page'` and `'inline'` are the screen drawn in a route or a show tree (P6), not presented. */
+  readonly host: 'dialog' | 'sheet' | 'page' | 'inline';
+  readonly label: string;
+  readonly title?: string;
+  readonly compiled?: CompiledFlow;
+  readonly record?: Row;
+  readonly args?: Row;
+  readonly selection?: {
+    readonly ids: readonly string[];
+    readonly count: number;
+  };
+  /** The effects of the dispatcher scope the flow was started in (4.13, I12). */
+  readonly effects?: () => DispatcherEffects;
+  readonly onSettle?: (result: FlowResult) => void;
+}
+/**
+ * The UI kit's overlay screens (P3-6): the framework presents them under the reserved keys
+ * `buro:quick`, `buro:peek` and `buro:flow` and resolves those keys from here only, never from
+ * the app's `components`.
+ */
+interface UIPresentationScreens {
+  readonly quick?: ComponentType<QuickScreenProps>;
+  readonly peek?: ComponentType<PeekScreenProps>;
+  /** A flow's host screen (P4 spec 4.15), in a dialog or a sheet. */
+  readonly flow?: ComponentType<FlowScreenProps>;
+  /** A modal action's block (P7 3.16), in a dialog or a sheet. */
+  readonly block?: ComponentType<BlockScreenProps>;
 }
 /**
  * What a host declares it understands about its `options` record: a flat
@@ -763,7 +1222,10 @@ type UIPresentationHost = ComponentType<UIPresentationHostProps> & {
  * simply renders nothing (no crash, no console noise): that is the expected
  * shape for an app that has not wired concrete hosts (yet).
  */
-type UIPresentationHosts = Readonly<Partial<Record<UIPresentationDescriptor['host'], UIPresentationHost>>>;
+type UIPresentationHosts = Readonly<Partial<Record<UIPresentHost, UIPresentationHost>>> & {
+  /** The UI kit's overlay screens (`shadcnPresentationHosts.screens`). */
+  readonly screens?: UIPresentationScreens;
+};
 interface UIPresentationsProps {
   readonly hosts: UIPresentationHosts;
 }
@@ -783,6 +1245,31 @@ interface UIPresentationsProps {
  */
 declare function UIPresentations({ hosts }: UIPresentationsProps): ReactElement;
 //#endregion
+//#region src/ui/use-ui-present.d.ts
+/**
+ * Reads the current activation: the surface from the nearest
+ * `UIActivationSurfaceProvider` (defaulting to `{ type: 'global' }` when
+ * there isn't one) plus a live snapshot of the app's resolver slices, if a
+ * `BuroProvider` is mounted above. Outside one, `slices` is `{}` — this
+ * hook (and `useUIPresent`, which is built on it) works standalone, e.g. in
+ * a unit test that only wires up `UIPresentationRuntimeProvider`.
+ */
+declare function useCurrentUIActivation(): UIActivationContext;
+/** An imperative present request; `activation` is captured automatically and need not (usually) be supplied. */
+type UIPresentInput = Omit<UIPresentRequest, 'activation'> & {
+  readonly activation?: Partial<UIActivationContext>;
+};
+type UIPresent = (request: UIPresentInput) => UIPresentResult;
+/**
+ * Returns a `present` function that captures the current activation
+ * (surface + resolver slices) at call time and forwards the request to the
+ * `UIPresentationRuntime` supplied by the nearest `UIPresentationRuntimeProvider`.
+ * A caller may override `surface` and/or `slices` explicitly via the
+ * `activation` field of the request; anything left unset falls back to the
+ * captured activation.
+ */
+declare function useUIPresent(): UIPresent;
+//#endregion
 //#region src/ui/mount.d.ts
 /**
  * Who renders the presentation stack.
@@ -790,8 +1277,10 @@ declare function UIPresentations({ hosts }: UIPresentationsProps): ReactElement;
  * `'framework'` (default) — `BuroProvider` mounts it beside `{children}`,
  * inside every framework provider. Presented components reach field
  * implementations, i18n, UI settings and the doc panel, but NOT providers the
- * app mounts inside `{children}` (dispatch, relation aggregator, link
- * component): those render strictly below the framework's own mount.
+ * app mounts inside `{children}` (the link component): those render strictly
+ * below the framework's own mount. The dispatcher, the navigation guard and the
+ * relation aggregator are mounted by `BuroProvider` around both, so they are
+ * reachable in either mode.
  *
  * `'app'` — the app renders `<BuroPresentationOutlet/>` itself, typically as
  * the last child of its own provider stack. Presented components then render
@@ -847,12 +1336,30 @@ interface BuroProviderProps<TSlices extends Record<string, SliceDefinition> = Re
    */
   resolver: Resolver<TSlices>;
   i18n: I18nFacade;
+  /**
+   * The `localStorage` key a language control (`useLanguageSwitch`,
+   * `<LanguageSwitch>`) saves the chosen locale under. Read it back at boot the
+   * same way (`loadLocale(key)`) so the choice survives a reload. Default
+   * `'buro:language'`.
+   */
+  languageStorageKey?: string;
   components: Record<string, unknown>;
   /**
    * Immutable, host-provided React field implementations. They are scoped to
    * this provider tree and are intentionally outside AppRuntime/manifests.
    */
   fieldImplementations?: FieldImplementationCatalog;
+  /**
+   * The app's block views (`composeBlockImplementations(...)`), keyed by block id. The renderer
+   * composes its built-in views first and these over them: an app entry with a built-in id
+   * replaces that view (with a development notice).
+   */
+  blockImplementations?: BlockImplementationCatalog;
+  /**
+   * The app's frame views (`composeFrameImplementations(...)`), keyed by frame id. The kit draws
+   * the built-in (`buro:`) frames itself; an app entry for one is ignored (P6-9).
+   */
+  frameImplementations?: FrameImplementationCatalog;
   /**
    * Article bodies for the documentation panel — the map of lazy loaders plus
    * an optional fallback locale.
@@ -885,8 +1392,10 @@ interface BuroProviderProps<TSlices extends Record<string, SliceDefinition> = Re
    * behavior: `BuroProvider` mounts `<UIPresentations/>` beside `{children}`.
    * `'app'` hands the mount to the app, which must render
    * `<BuroPresentationOutlet/>` inside its own provider stack — the only way a
-   * presented component can reach app-level providers (dispatch, relation
-   * aggregator, link component) as the SAME instances the app tree uses.
+   * presented component can reach app-level providers (the link component) as
+   * the SAME instances the app tree uses. The dispatcher, the navigation guard
+   * and the relation aggregator are the framework's own and reach presented
+   * components in both modes.
    */
   presentations?: PresentationsMode;
   /**
@@ -900,90 +1409,66 @@ interface BuroProviderProps<TSlices extends Record<string, SliceDefinition> = Re
    * Omitted → no events are emitted and no emission site does any work.
    */
   audit?: Audit;
+  /**
+   * Overrides for the dispatcher's effects, merged per key over the defaults
+   * `BuroProvider` supplies: `refetch` invalidates the `buro-data` queries,
+   * `notify` reaches the notification sink a UI kit's toaster registers (a
+   * no-op without one), `redirect` navigates through the `RouterAdapter` and is
+   * skipped when it resolves to the current pathname with no query of its own
+   * (the built-in delete fired from a filtered list), `setClipboard` and
+   * `download` use the browser, `modal` presents through the presentation
+   * runtime. `clearSelection` has no default — the caller owns the selection.
+   * Read through a ref, so an inline object neither rebuilds the dispatcher nor
+   * goes stale.
+   */
+  effects?: Partial<DispatcherEffects>;
+  /**
+   * The relation aggregator `<BuroProvider>` mounts around the app and its overlays (when a
+   * `dataRuntime` is given). `maxPage` is the largest page the application's provider serves:
+   * an id batch is read in chunks of this many ids, and a `by` read asks for at most this many
+   * rows. Default 100.
+   */
+  relationBatch?: {
+    readonly maxPage?: number;
+  };
   children: ReactNode;
 }
-declare function BuroProvider<TSlices extends Record<string, SliceDefinition>>({ app, dataRuntime, authProvider, uiSettings, resolver, i18n, components, fieldImplementations, docs, initialManifest, manifestHydrationScope, presentationHosts, presentations, audit, children }: BuroProviderProps<TSlices>): ReactElement;
+declare function BuroProvider<TSlices extends Record<string, SliceDefinition>>({ app, dataRuntime, authProvider, uiSettings, resolver, i18n, languageStorageKey, components, fieldImplementations, blockImplementations, frameImplementations, docs, initialManifest, manifestHydrationScope, presentationHosts, presentations, audit, effects, relationBatch, children }: BuroProviderProps<TSlices>): ReactElement;
 //#endregion
 //#region src/audit/context.d.ts
+/** What an application emits through: its own `app.*` events, and the correlation it shares. */
+interface AppAudit {
+  /**
+   * Emits an application event. Its `type` must start with `app.`: a framework type
+   * (`form.submit`, `flow.submit`, `nav.enter`) is dropped — the framework emits those itself —
+   * with a development `console.error` naming it.
+   */
+  emit(input: AppAuditEventInput, options?: {
+    readonly initiates?: boolean;
+  }): void;
+  /** The id shared by everything the current user action caused. */
+  currentCorrelationId(): string;
+  readonly sessionId: string;
+}
 /**
  * The application's audit emitter, or `null` when `<BuroProvider>` got no
  * `audit` prop.
  *
  * Call sites guard with `audit?.emit(...)`, and that guard is deliberate: it is
  * what makes an app without auditing pay nothing, because the work of building
- * an event (a form diff, a list snapshot) never starts.
+ * an event (a list snapshot) never starts.
  *
  * Applications use it to write their own events into the same stream — custom
  * pages and hand-written components are otherwise blind spots by construction:
  *
  *   const audit = useAudit();
  *   audit?.emit({ type: 'app.export.started', payload: { format: 'xlsx' } });
- */
-declare function useAudit(): Audit | null;
-//#endregion
-//#region src/audit/form-diff.d.ts
-interface BuildFormDiffArgs {
-  /** Values as they were when the form opened (its baseline). */
-  readonly before: Readonly<Record<string, unknown>>;
-  /** Values at submit time. */
-  readonly after: Readonly<Record<string, unknown>>;
-  /** The form's field definitions, keyed by field name — the source of `sensitive`. */
-  readonly fields: Readonly<Record<string, unknown>>;
-}
-/**
- * Build the `diff` of a `form.submit` audit event.
- *
- * Shared by both form hosts (`useDeclarativeForm` and `<ResourceForm>`) on
- * purpose: two copies of the redaction branch is how a sensitive field ends up
- * redacted on one path and not the other.
- *
- * A field the caller did not declare is redacted rather than emitted — an
- * unknown field cannot be proven non-sensitive, and a create form can carry
- * values for fields seeded from outside the declaration. `fields` is caller
- * data too (its keys can be attacker-influenced the same way `before`/
- * `after` can), so the lookup uses `Object.hasOwn` rather than an
- * `=== undefined` check: a key like `toString` or `constructor` is NOT
- * "undefined" on a plain object — it resolves through the prototype chain to
- * a built-in function — and treating that as "known" would emit whatever
- * value rode in under that name raw.
- */
-declare function buildFormDiff(args: BuildFormDiffArgs): Record<string, AuditFieldDiff>;
-//#endregion
-//#region src/audit/use-form-submit-audit.d.ts
-interface FormSubmitAuditArgs {
-  /** Values as the form opened — captured BEFORE the write, since a host may re-baseline after it. */
-  readonly before: Readonly<Record<string, unknown>>;
-  readonly after: Readonly<Record<string, unknown>>;
-  readonly fields: Readonly<Record<string, unknown>>;
-  readonly outcome: 'success' | 'error' | 'invalid';
-  readonly resource?: string;
-  readonly recordId?: string;
-  readonly view?: 'create' | 'edit';
-  /**
-   * A backend-reported error code (e.g. `'backend-500'`, design doc §4.1) —
-   * plumbing for a host to report WHY an `'error'` outcome happened, distinct
-   * from `audit-diff-build-failed` below (which means the audit machinery
-   * itself, not the submit, failed). Ignored on any other outcome.
-   */
-  readonly errorCode?: string;
-}
-interface FormSubmitAudit {
-  /**
-   * False when the app configured no sink. Hosts check it before copying their
-   * values — that check is what makes an unaudited app pay nothing.
-   */
-  readonly enabled: boolean;
-  readonly emit: (args: FormSubmitAuditArgs) => void;
-}
-/**
- * The single place a `form.submit` event is constructed.
  *
- * Buro has two independent form hosts (`useDeclarativeForm` here and
- * `<ResourceForm>` in `@burojs/ui-shadcn`). They share this hook rather than a
- * copied block so the redaction branch cannot drift between them, and so a
- * third host does not become a third copy.
+ * Only `app.*` events pass (REF-29): the framework's own events go through an internal emitter,
+ * so an application can never forge a `form.submit` or a `flow.submit`. The `Audit` object
+ * `createAudit` returns is unchanged for the application's own transport code.
  */
-declare function useFormSubmitAudit(): FormSubmitAudit;
+declare function useAudit(): AppAudit | null;
 //#endregion
 //#region src/ui-settings/provider.d.ts
 interface UiSettingsProviderProps {
@@ -1102,6 +1587,13 @@ declare function useLayerRuntime(): LayerRuntime;
 declare function useApplicationSnapshot(): ApplicationSnapshot;
 declare function useProjection(target: SnapshotEntityTargetInput): PortableProjection | undefined;
 declare function useLayerStatus(id: string): LayerStatus;
+/**
+ * @internal The app's trusted block catalogue over the committed snapshot (P4-D): the built-in
+ * blocks and every registered one. A flow's form and review tree compile against it, so
+ * `l.place(appBlock)` resolves (spec 3.6). One lookup per snapshot, so a compile memoised by the
+ * lookup hits across renders.
+ */
+declare function useFlowFormCatalog(): BlockLookup;
 //#endregion
 //#region src/context.d.ts
 declare const I18nContext: import("react").Context<I18nFacade | null>;
@@ -1116,6 +1608,8 @@ interface ResourceContextValue {
   resource?: string;
 }
 declare const ResourceContext: import("react").Context<ResourceContextValue>;
+/** Where the chosen locale is persisted unless `<BuroProvider languageStorageKey>` says otherwise. */
+declare const DEFAULT_LANGUAGE_STORAGE_KEY = "buro:language";
 //#endregion
 //#region src/data/action-data-access.d.ts
 /** Runtime-owned action DI. Descriptor identity always comes from the current lease. */
@@ -1127,6 +1621,101 @@ declare function useApp(): AppRuntime;
 //#region src/hooks/use-resource.d.ts
 declare function useResource(ref: ResourceRefInput): RegistryResource | undefined;
 //#endregion
+//#region src/frames/context.d.ts
+/** The app's frame catalogue; `{}` outside a provider. @internal */
+declare function useFrameImplementations(): FrameImplementationCatalog;
+//#endregion
+//#region src/frames/check-context.d.ts
+/** The kit's frame pieces a frame view places. */
+type FramePiece = 'RecordTitle' | 'RecordActions' | 'CopyId' | 'FormActions' | 'ListControls' | 'ListFilters' | 'ListFlows' | 'ListLive' | 'ListSavedViews' | 'ListColumns' | 'ListExport' | 'ListCreate' | 'ListBody' | 'ListBulkBar';
+/**
+ * What a frame's pieces report to (`@internal`): the record frame host counts their mounts to
+ * check a custom frame's obligations at runtime (P6-15), and `checkFrame` renders a view
+ * alone with `stub` set, so each piece draws a marker instead of reading the record chrome.
+ */
+interface FrameCheckValue {
+  /** Draw `<span data-check-piece>` instead of the piece (`checkFrame`). */
+  readonly stub: boolean;
+  /** Records a mount; the returned function records the unmount. */
+  mount(piece: FramePiece): () => void;
+}
+/** @internal */
+declare const FrameCheckContext: import("react").Context<FrameCheckValue | null>;
+/** @internal Records the calling piece's mount while it is mounted; returns the context. */
+declare function useFramePiece(piece: FramePiece): FrameCheckValue | null;
+//#endregion
+//#region src/frames/use-frame-t.d.ts
+/** A frame view's `t`: reads `frames.<id>.<key>` (the block convention, foundation 12). @internal */
+declare function useFrameT(id: string): FrameTranslate;
+//#endregion
+//#region src/blocks/use-placement.d.ts
+/** A placement as its host draws it (spec 8.1, 8.2). */
+interface PlacementView {
+  readonly state: 'absent' | 'pending' | 'ready' | 'failed';
+  /**
+   * Refetches what failed. Absent for a refused prop and for a block without a view: Retry
+   * cannot help them.
+   */
+  readonly retry?: () => void;
+  readonly error?: unknown;
+  readonly block: EntityRef;
+  /** The app's view of the block (`<BuroProvider blockImplementations>`), if it has one. */
+  readonly appImplementation?: BlockImplementation<any>;
+  /** What the view is rendered with, once the placement is ready. */
+  readonly viewProps?: BlockViewProps<unknown>;
+}
+/**
+ * A placement of the screen being rendered, by its key (a nested placement by its derived key,
+ * `<host>.<prop>`): its state over the plan (access, `when`, its sources) and its own mount (props
+ * validated, `data` entries), the app's view of its block and the props the view receives.
+ * `controller` defaults to the record frame's, else to the custom page's body around it.
+ */
+declare function usePlacement(key: string, controller?: Pick<FormController, 'plan' | 'placement' | 'retry'>): PlacementView;
+//#endregion
+//#region src/forms/controller/use-page-screen.d.ts
+interface PageScreen {
+  /** The page's one plan; empty for a failure marker. */
+  readonly plan: ScreenPlan;
+  /** Refetches only the failed requests under these source names (`block:<key>` for a placement). */
+  retry(sources: readonly string[]): void;
+  /** A placement's runtime at mount, by key. */
+  placement(key: string): PlacementRuntime | undefined;
+  /** Provides the page to `usePlacement(key)` below it, as a record frame does on a record. */
+  readonly PlacementScope: (props: {
+    readonly children: ReactNode;
+  }) => ReactElement;
+}
+/**
+ * @internal The resolver and planner half of a custom page's body (P1b+P1c decision 52), for the
+ * page host: the screen's sources resolved with no record and no form values, the access of the
+ * signed-in user (no resource rules: a page has none), and the page's one `planScreen` call, with
+ * what is open from the surrounding `ScreenStateProvider` and the placements' block data. As on a
+ * record, the plan's `blockDemand` is fed back to the resolver, so a placement under a panel whose
+ * access is pending or denied never has its `data` requested. A `null` screen (a failure marker)
+ * resolves and plans nothing.
+ */
+declare function usePageScreen(compiled: CompiledScreen | null): PageScreen;
+//#endregion
+//#region src/forms/controller/route-source.d.ts
+/**
+ * The `route` source of the screen below (spec 4.5): `{ id }` from the record route on show and
+ * edit, `{}` on its create, a page's declared params from the page host. Only those routes
+ * provide it; any other mount — a `<RecordScreen>` outside the record route, a nested screen —
+ * reads `{}`. Values are what the route parsed (a page param's schema may coerce); `''` reads
+ * `null` (the resolver normalises it).
+ *
+ * @internal Provided by `@burojs/ui-shadcn`'s record route and page host.
+ */
+declare const RouteSourceContext: import("react").Context<Readonly<Record<string, unknown>> | null>;
+//#endregion
+//#region src/blocks/use-route-list-implementation.d.ts
+/**
+ * The app's view of the built-in `buro:related-list` block (`<BuroProvider blockImplementations>`),
+ * or `undefined`: an app entry replaces the list view everywhere, the route list included, so
+ * `ResourceListPage` renders it instead of the built-in view.
+ */
+declare function useRouteListImplementation(): BlockImplementation<any> | undefined;
+//#endregion
 //#region src/fields/provider.d.ts
 interface FieldImplementationProviderProps {
   readonly fieldImplementations?: FieldImplementationCatalog;
@@ -1145,6 +1734,29 @@ declare function useFieldImplementationCatalog(): FieldImplementationCatalog;
 declare function resolveFieldImplementation(catalog: FieldImplementationCatalog, input: UseFieldImplementationArgs): ResolvedFieldImplementation;
 declare function useFieldImplementation(input: UseFieldImplementationArgs): ResolvedFieldImplementation;
 //#endregion
+//#region src/fields/field-implementation.d.ts
+type MetaOf<S extends StandardSchemaV1> = InferSchemaOutput<S> extends Readonly<Record<string, unknown>> ? InferSchemaOutput<S> : never;
+/**
+ * A field implementation whose `meta` is typed by a schema (P7 3.3): the schema's output is the
+ * type of `props.meta` in every surface, and the framework applies the schema to the resolved
+ * `meta` at render — a refusal renders the field misconfigured, never the implementation.
+ *
+ * ```tsx
+ * const hsCode = fieldImplementation({
+ *   meta: z.object({ origin: z.string().nullable() }),
+ *   Input: ({ meta: { origin } }) => <CodePicker origin={origin} />,
+ * });
+ * ```
+ */
+declare function fieldImplementation<const S extends StandardSchemaV1, T = unknown>(implementation: {
+  readonly meta: S;
+  readonly Input?: ComponentType<ScalarInputProps<T, MetaOf<S>>>;
+  readonly Display?: ComponentType<ScalarDisplayProps<T, MetaOf<S>>>;
+  readonly CollectionInput?: ComponentType<CollectionInputProps<T, MetaOf<S>>>;
+  readonly CollectionDisplay?: ComponentType<CollectionDisplayProps<T, MetaOf<S>>>;
+  readonly layout?: FieldImplementationLayout;
+}): FieldImplementation<T, MetaOf<S>>;
+//#endregion
 //#region src/fields/define-field-with-implementation.d.ts
 type FieldDeclarationOverrides<TMeta extends Readonly<Record<string, unknown>>> = Omit<FieldDeclaration, 'type' | 'format' | 'meta'> & {
   readonly meta?: TMeta;
@@ -1163,6 +1775,69 @@ interface DefinedField<TMeta extends Readonly<Record<string, unknown>> = Readonl
  */
 declare function defineFieldWithImplementation<TMeta extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>>(declaration: FieldDeclaration, implementation: FieldImplementation<any, TMeta>): DefinedField<TMeta>;
 //#endregion
+//#region src/fields/use-field-meta.d.ts
+/**
+ * What a field's input receives as `meta` (P7 3.2, 3.3): its refs read from the owner's sources,
+ * then the implementation's schema over the result. `pending` while a source or an asynchronous
+ * schema is; `failed` once a source failed or the schema refused it, with the reason a
+ * development message names.
+ */
+type FieldMetaState = {
+  readonly status: 'ready';
+  readonly meta: Readonly<Record<string, unknown>>;
+} | {
+  readonly status: 'pending';
+} | {
+  readonly status: 'failed';
+  readonly reason: string;
+};
+/**
+ * The sources a field's `meta` reads when its owner supplies none of its own: `record` (the
+ * record the field renders from, `null` in create), `values` (the live form values), `scope` and
+ * `user`. An owner's own states (`extra`: a form controller's projected `record` and `values`, a
+ * flow's `with` and `args`) replace these by name, so a field decided pending by P5 stays pending.
+ *
+ * @internal
+ */
+declare function useFieldMetaSources(input: {
+  readonly record: Readonly<Record<string, unknown>> | undefined;
+  readonly values: Readonly<Record<string, unknown>> | undefined;
+  readonly extra?: ScreenSources | undefined;
+}): ScreenSources;
+/**
+ * A field's `meta` as its implementation receives it (P7 3.2, 3.3). `implementation` is the
+ * catalogue entry the field resolved to: its `meta` schema, when it declares one, is applied to
+ * the resolved meta, and an asynchronous schema keeps the state `pending` until it settles.
+ * The same state object is returned while the values the refs read are the same.
+ *
+ * @internal
+ */
+declare function useFieldMeta(field: Pick<FieldDeclaration, 'meta'>, implementation: FieldImplementation<unknown> | undefined, sources: ScreenSources): FieldMetaState;
+//#endregion
+//#region src/fields/use-candidates-access.d.ts
+/**
+ * Whether a relation's select may read its target under its candidates (P7 3.4): every field a
+ * candidate names must be one its user may view in the target. A predicate on a hidden field is
+ * never sent — it would filter on data the user cannot see, and the rows offered would tell.
+ */
+type CandidatesAccess = {
+  readonly status: 'pending';
+} | {
+  readonly status: 'allowed';
+} | {
+  readonly status: 'forbidden';
+  readonly field: string;
+};
+/**
+ * `pending` while the permission map loads and a field decision depends on it; `forbidden`, with
+ * the first such field, when a candidate names a field the user may not view; else `allowed`.
+ * No candidates is `allowed` whatever the map says. A target the application lacks is closed
+ * (every field hidden), so a candidate on it is `forbidden`.
+ *
+ * @internal
+ */
+declare function useCandidatesAccess(target: string, candidates: readonly RelationCandidate[] | undefined): CandidatesAccess;
+//#endregion
 //#region src/hooks/use-doc.d.ts
 /**
  * Contextual documentation for one address, resolved at render time.
@@ -1370,12 +2045,11 @@ declare function useVisibilityCtx(): AppContext;
  * standalone" precedent: a headless hook meant to be instantiable via a bare
  * `renderHook(() => useX(...))`, with no wrapper, needs graceful
  * degradation rather than `useCtx`'s hard `must be used within a
- * BuroProvider` throw. `useDeclarativeForm` (`../forms/use-declarative-
- * form.ts`, Task 4) is the first consumer: a form with no conditional
- * (`visible`/predicate `required`/`disabled`) fields must not need a full
- * app `BuroProvider` tree just to mount and be unit-tested — Task 3's
- * `renderHook(() => useDeclarativeForm(...))` tests (no wrapper) must keep
- * passing once the controller starts reading a visibility ctx.
+ * BuroProvider` throw. The form controller (`useFormController`) is the
+ * consumer: a form with no predicate `required`/`disabled` fields must not
+ * need a full app `BuroProvider` tree just to mount and be unit-tested —
+ * `renderHook(() => useFormController(...))` tests (no wrapper) keep passing
+ * while the controller reads a visibility ctx.
  *
  * Inside a real `BuroProvider`, this reads the same live resolver snapshot
  * `useVisibilityCtx` does (including reactivity to slice updates), just
@@ -1386,29 +2060,6 @@ declare function useVisibilityCtx(): AppContext;
  */
 declare function useOptionalVisibilityCtx(): AppContext;
 //#endregion
-//#region src/hooks/use-visible-templates.d.ts
-/**
- * The document types a user may be offered for `resource` right now.
- *
- * `templates.items` filtered by each entry's `visible` predicate against the
- * live app context (`{ permissions, scope, user }`) — the seam that makes a
- * type set follow scope. The hook re-runs when the context slices move, so a
- * picker built on it narrows the moment the user switches market, tenant or
- * role, with no code in the picker that knows about any of them.
- *
- * Returns `[]` for an unknown resource and for a resource that declares no
- * `templates` — "no types on offer", which is the honest answer for a resource
- * that has none, and lets a caller render its picker unconditionally.
- *
- * ⚠️ **This is the OFFER, not an authorization boundary.** A type hidden here
- * is still renderable by a record that already carries it (a row that exists
- * has to stay readable) and still reachable by a hand-typed create URL — the
- * page-level guard remains the host's, exactly as `ResourceConfig.visible`
- * gates navigation rather than routes. Use a capability rule where the
- * boundary has to hold.
- */
-declare function useVisibleTemplates(resource: string): DocumentTemplate[];
-//#endregion
 //#region src/hooks/use-capability.d.ts
 interface UseCapabilityArgs {
   /** Resource whose rules apply. */
@@ -1460,6 +2111,131 @@ declare function useCapabilityResolver(resource: string, record?: unknown, mode?
  */
 declare function useCapability(capability: Capability, args: UseCapabilityArgs): CapabilityDecision;
 //#endregion
+//#region src/hooks/url-state/codec.d.ts
+type ResourceFilter = FilterExpression<ErasedResourceHandle>;
+type ResourceSort = SortExpression<ErasedResourceHandle>;
+/**
+ * Deliberate bounds for untrusted URL AST payloads. The values are large
+ * enough for an interactive list, while preventing a pasted URL from making
+ * server rendering or the first client render do unbounded recursive work.
+ */
+declare const RESOURCE_URL_STATE_LIMITS: {
+  readonly maxEncodedBytes: 16384;
+  readonly maxFilters: 50;
+  readonly maxFilterDepth: 16;
+  readonly maxFilterNodes: 200;
+  readonly maxSortEntries: 20;
+};
+/** Typed, router-independent state for an interactive resource list. */
+/**
+ * Suffixes of a list namespace that are not list state (P3-26): `?<namespace>.open=<id>`, a
+ * placement's deep link, is page state. A list write keeps them; the codec ignores them.
+ */
+declare const RESERVED_LIST_SUFFIXES: readonly ["open"];
+interface ResourceUrlState {
+  filters: readonly ResourceFilter[];
+  /** The builder group. `filters` above is the PINNED slot — always ANDed. */
+  filterGroup: FilterGroup;
+  sort: ResourceSort;
+  page: number;
+  pageSize: number;
+  search: string;
+  visibleColumns: string[] | null;
+}
+/**
+ * Kept temporarily as a source-level migration seam for the list controller.
+ * URL AST values preserve their JSON primitive type and no longer use this
+ * hint for serialization or decoding.
+ */
+type FieldType = 'string' | 'number' | 'boolean' | 'enum' | 'relation' | 'date';
+interface CodecOptions {
+  /** Resource key — used as the parameter namespace prefix. */
+  resource: string;
+  /** Values equal to these defaults are omitted from the URL. */
+  defaults: ResourceUrlState;
+  /** @deprecated AST envelopes preserve primitive value types directly. */
+  fieldTypes?: Record<string, FieldType>;
+}
+/** Serialize one resource's URL slice. AST state is versioned JSON/base64url. */
+declare function serializeResourceState(state: ResourceUrlState, opts: CodecOptions): URLSearchParams;
+/** Decode one resource's URL slice; malformed AST envelopes reset atomically. */
+declare function deserializeResourceState(params: URLSearchParams, opts: CodecOptions): ResourceUrlState;
+//#endregion
+//#region src/hooks/url-state/hidden-predicates.d.ts
+type Expression = FilterExpression<ErasedResourceHandle>;
+/** Every field an expression names, in order, duplicates kept out. */
+declare function filterFields(expression: Expression): readonly string[];
+//#endregion
+//#region src/hooks/use-field-access.d.ts
+/**
+ * Every declared field's view and edit decision for the signed-in user (P5 spec 3.4) — the one
+ * `resolveFieldAccess`, never a second branch. `reach: 'record'` decides over `row` (absent: a
+ * create); `'every'` decides for every row at once (the record probe), and ignores `row`.
+ * Memoised by the rules, the user, the scope, the permission map and the row (Known finding 19).
+ * A loading map makes every guarded field `pending`; a resource the registry lacks decides
+ * nothing (`{}`).
+ */
+declare function useFieldAccess(resource: string, reach: FieldReach, row?: unknown): FieldAccessMap;
+/**
+ * The one list predicate of a resource (P5 spec 3.7, decision P5-18): field view in any-record
+ * reach and `column` rules, both with the record probe. Every list surface — the controller's
+ * columns and filter offer, the table, the export dialog, the picker and the palette — reads it.
+ * `pending` while the map loads and a decision depends on it; a resource the registry lacks is
+ * closed (no field, no column).
+ */
+declare function useListAccess(resource: string): ListAccess;
+/**
+ * A list row as view code may read it (P5 spec 3.6.6, plan ruling 9): every field its user may
+ * not view for every row left out — the id kept. For `renderCell`, `rowHref`, cell renderers and
+ * selection-aware views; rules, item-action gates and action handlers keep the row as read
+ * (policy). Memoised per row object while the decisions hold (Known finding 21: a row is never
+ * projected with decisions computed for another).
+ */
+declare function useViewRow(resource: string): <T extends object>(row: T) => T;
+//#endregion
+//#region src/hooks/use-projected-record.d.ts
+/** A record as view code may read it: the fields its user may view, or nothing yet. */
+interface ProjectedRecord {
+  /** `pending` while a decision a read depends on is undecided, or the row is placeholder data. */
+  readonly status: 'pending' | 'ready';
+  /** The row without every field its user may not view (the id kept); `null` for no row. */
+  readonly value: Readonly<Record<string, unknown>> | null;
+}
+/**
+ * One record of `resource`, projected by field view in record reach (P5 spec 3.6): a title, a
+ * recent label, a breadcrumb or a peek reads this and never the row as read. `pending` while any
+ * decision is undecided (an undecided field is never shown) and for placeholder data — rows of the
+ * previous record or page never decide a title (Known finding 21). Decisions are keyed by the row
+ * object they were computed for.
+ */
+declare function useProjectedRecord(resource: string, row: unknown, opts?: {
+  readonly placeholder?: boolean;
+}): ProjectedRecord;
+/**
+ * A record's title as view code may show it (P5 spec 3.6, decision P5-27): `useRecordTitle` over
+ * the projected row, so a display field or a `recordTitle` hook never reads a field its user may
+ * not view. A hidden or undecided title falls back to the `#id` form.
+ */
+declare function useProjectedTitle(resource: string | undefined, id: unknown, row: unknown, opts?: {
+  readonly placeholder?: boolean;
+}): string;
+//#endregion
+//#region src/policy-side-channel.d.ts
+/**
+ * The record as read, for policy: item-action gates and the flows a record page starts.
+ * `fallback` (the controller's own projected `record`) when none was attached.
+ *
+ * @internal `@burojs/ui-shadcn` reads it; view code never does.
+ */
+declare function policyRecordOf(controller: object, fallback?: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>> | undefined;
+/**
+ * The rows as read, for policy: selection, bulk and item-action gates. `fallback` (the
+ * controller's own `rows`) when none was attached, as for a hand-written controller.
+ *
+ * @internal `@burojs/ui-shadcn` reads it; view code never does.
+ */
+declare function policyRowsOf<T extends Record<string, unknown>>(controller: object, fallback: T[]): T[];
+//#endregion
 //#region src/hooks/use-availability.d.ts
 /**
  * One resolver bound to a resource, for callers that ask about MANY operations
@@ -1496,18 +2272,23 @@ declare function useAvailability(resource: string, operation: string, record?: u
 //#region src/hooks/use-app-actions.d.ts
 interface AppActionEntry {
   readonly name: string;
-  readonly label: {
-    single: string;
-    plural?: string;
-  };
-  readonly kind: 'modal' | 'link';
-  readonly component?: string;
+  /** The declared default; a renderer resolves `appActions.<name>` in the bundle over it. */
+  readonly label: string;
+  /** `'flow'`: an app flow (P4); run it with `useAction({ appAction: name })`. */
+  readonly kind: 'modal' | 'link' | 'flow';
+  /** `kind: 'modal'`: the block the action presents (P7 3.16), with its portable props. */
+  readonly block?: EntityRef;
   readonly props?: Readonly<Record<string, unknown>>;
-  readonly surface?: 'dialog' | 'sheet';
+  readonly host?: 'dialog' | 'sheet';
   readonly to?: string;
   readonly icon?: string;
   /** Present when a rule allows it but disables it; the rule's own reason. */
   readonly disabledReason?: string;
+  /**
+   * A flow hosted on a custom page (`host: { page }`, P7 3.15): the page's own path. Its control
+   * is a guarded link, not a runner; the entry exists only for a user who may open the page.
+   */
+  readonly hostHref?: string;
 }
 /**
  * Every app-level action (`defineAppAction`, `registerAppAction`) the
@@ -1525,6 +2306,10 @@ interface AppActionEntry {
  * the resource argument) without inventing a second gating engine next to
  * `useAvailabilityGate`.
  *
+ * An app flow (`kind: 'flow'`, P4) is gated by the flow's own gate (`resolveFlowGate`: its
+ * `requires`, its mutation's `requires`, and the same `action/run` rules at the same address),
+ * the one gate its button and `useAction` run; while permissions load it is left out.
+ *
  * Rule-hidden (or absent) actions are dropped from the list entirely; a rule
  * that allows-but-disables an action keeps it in the list with its
  * `disabledReason` set so a caller can render it inert instead of missing.
@@ -1538,12 +2323,14 @@ declare function useSetSlice<TName extends string = string>(name: TName): (value
 declare function useT(): (key: string, options?: {
   resource?: string;
   params?: Record<string, unknown>;
+  count?: number;
 }) => string;
 /**
  * Provider-OPTIONAL translator. Behaves like {@link useT} when mounted inside a
  * `BuroProvider`, but does NOT throw when there is no i18n context —
- * instead it returns the supplied `defaultValue` (interpolated with `params`),
- * falling back to the raw key.
+ * instead it returns the supplied `defaultValue` (interpolated with `params`,
+ * and with `count` as `{{count}}` when one is given), falling back to the raw
+ * key.
  *
  * Use this for components that ship in `@burojs/ui-shadcn` yet may render
  * standalone (outside the provider) — e.g. `<LoginForm>` on a pre-auth screen,
@@ -1554,13 +2341,13 @@ declare function useOptionalT(): (key: string, options?: {
   resource?: string;
   params?: Record<string, unknown>;
   defaultValue?: string;
+  count?: number;
 }) => string;
 /**
  * The active locale code (e.g. `'ru'` / `'en'`), or `'en'` when no i18n
- * provider is mounted. Powers per-locale DATA labels — resolve a
- * `LocalizedText` (enum option labels, etc.) with `resolveLocalizedText(text,
- * useLocale())`. Provider-optional so ui-shadcn components can render
- * standalone.
+ * provider is mounted. Powers locale-dependent formatting and re-renders a
+ * component on a language switch. Provider-optional so ui-shadcn components
+ * can render standalone.
  */
 declare function useLocale(): string;
 /**
@@ -1568,8 +2355,8 @@ declare function useLocale(): string;
  *
  * The difference from {@link useLocale} is the whole point: `useLocale`
  * collapses "the app is running in English" and "there is no app" into the same
- * `'en'`, which is fine for resolving a `LocalizedText` (English is a defensible
- * last resort for a label) and wrong for anything that has its own fallback to
+ * `'en'`, which is fine for picking a label language (English is a defensible
+ * last resort) and wrong for anything that has its own fallback to
  * fall back TO. A caller that already knows what "nobody chose a locale" means
  * for it — `@burojs/ui-shadcn`'s `Intl` formatters resolve a stored preference
  * in that case — must be able to tell the two apart, and with `useLocale` it
@@ -1587,6 +2374,11 @@ declare function useOptionalLocale(): string | undefined;
  * so the choice survives a real reload. No-op without a provider.
  */
 declare function useChangeLocale(): (locale: string) => void;
+/**
+ * The `localStorage` key a language control persists the chosen locale under:
+ * `<BuroProvider languageStorageKey>`, or `'buro:language'` without one.
+ */
+declare function useLanguageStorageKey(): string;
 /**
  * Render-time translator, resource-scoped and provider-optional. The canonical
  * name for the i18n content model (react-admin `useTranslate` / i18next `t`).
@@ -1596,6 +2388,7 @@ declare function useChangeLocale(): (locale: string) => void;
 declare function useTranslate(): (key: string, options?: {
   resource?: string;
   params?: Record<string, unknown>;
+  count?: number;
 }) => string;
 /**
  * The `has` + `t` capabilities bound to the ambient resource, for the pure
@@ -1657,8 +2450,20 @@ interface TestIdBuilder {
   listToolbar: (resource: string) => string;
   listAction: (resource: string, actionName: string) => string;
   listSearch: (resource: string) => string;
+  /** The filter bar's "Some saved filters were not applied" notice (P5 spec 3.7). */
+  listPredicatesDropped: (resource: string) => string;
+  /** A list frame's slot, around its planned tree (P7-34). */
+  listSlot: (resource: string, slot: string) => string;
+  /** A resource-level flow on the route list's toolbar (P7-31). */
+  listFlow: (resource: string, flowName: string) => string;
+  /** The toolbar's overflow menu of resource-level flows. */
+  listFlowsMenu: (resource: string) => string;
   listFilter: (resource: string, fieldName: string) => string;
   listTable: (resource: string) => string;
+  /** A `related-list` card (`view: 'cards'`): the placement key and the row id. */
+  relatedCard: (key: string, recordId: string) => string;
+  /** A `related-list` timeline entry (`view: 'timeline'`): the placement key and the row id. */
+  timelineEntry: (key: string, recordId: string) => string;
   listRow: (resource: string, recordId: string) => string;
   listCell: (resource: string, recordId: string, fieldName: string) => string;
   listRowAction: (resource: string, recordId: string, actionName: string) => string;
@@ -1694,39 +2499,64 @@ interface TestIdBuilder {
   pageEdit: (resource: string, recordId: string) => string;
   pageCreate: (resource: string) => string;
   /**
-   * The panel a detail surface renders in place of a field set when
-   * `ResourceConfig.templates.fallback: 'unsupported'` refuses an unrecognised
-   * document type. Keyed by RESOURCE and not by the offending value: the value
+   * The notice a record screen renders for a record whose discriminator value
+   * no declared type holds (P1b+P1c decision 64). Keyed by RESOURCE and not by the offending value: the value
    * is by definition one the application does not know, so a testid built from
    * it could not be written down in advance by the test that looks for it.
    */
   unsupportedDocumentType: (resource: string) => string;
-  resourceTab: (resource: string, tabKey: string, recordId?: string) => string;
-  subresourceTabs: (parentResource: string) => string;
-  subresourceTab: (tabKey: string) => string;
-  subresourceBody: (childResource: string) => string;
-  form: (resource: string, view: string, recordId?: string) => string;
   /**
-   * One declared field GROUP (`views.fields` as sections) — the `<section>`
-   * (or, when `collapsed`, the `<details>`) `<ResourceForm>` wraps each group
-   * in.
-   *
-   * ⚠️ Renamed from `formSection`, which composed `form-section:…` and had
-   * **no producer** — the component has always emitted `form-group:…` (SP9
-   * task 5, the same sweep that found the whole `picker-*` family addressing
-   * nothing).
+   * A quick overlay (sheet or dialog; P3-21) by its top entry: `quick-sheet:<resource>:<id>`, or
+   * `quick-sheet:<resource>` for a create.
+   */
+  quickSheet: (resource: string, recordId?: string) => string;
+  /** The quick sheet's Back (when its history is deeper than one entry). */
+  quickBack: () => string;
+  /** The quick overlay's close button. */
+  quickClose: () => string;
+  /** The quick overlay's "Open as page" link. */
+  quickOpenPage: () => string;
+  /** A peek (the hover preview of a relation display's record, P3-22): `peek:<resource>:<key>`. */
+  peek: (resource: string, key: string) => string;
+  /**
+   * A flow's host (P4 spec 4.15) and its controls, by the flow's identity
+   * (`'<ns>:<resource>/actions/<name>'`, `'app/<name>'`): `flow-host:<flowId>`, and
+   * `flow-<control>:<flowId>` for each control.
    */
-  formGroup: (resource: string, view: string, groupKey: string) => string;
+  flowHost: (flowId: string) => string;
+  /** The page-hosted flow's route body (P6): `page-flow:<flowId>`. */
+  pageFlow: (flowId: string) => string;
+  /** An inline flow's placement (P6): `inline-flow:<flowId>:<placement key>`. */
+  inlineFlow: (flowId: string, key: string) => string;
+  flowSubmit: (flowId: string) => string;
+  flowBack: (flowId: string) => string;
+  /** The footer's Cancel: closes through the dismiss guard. */
+  flowCancel: (flowId: string) => string;
+  /** The header's ✕, and an outcome screen's Close. */
+  flowClose: (flowId: string) => string;
+  /** The outcome message (rejected, failed, unknown, busy). */
+  flowOutcome: (flowId: string) => string;
+  flowCheckAgain: (flowId: string) => string;
+  flowSendAsNew: (flowId: string) => string;
+  flowStartOver: (flowId: string) => string;
+  flowResend: (flowId: string) => string;
+  /** The draft-found banner of a flow's form, and its two buttons (`:restore`, `:discard`). */
+  flowDraft: (flowId: string) => string;
+  /** A bulk flow's per-outcome summary. */
+  bulkSummary: (resource: string, actionName: string) => string;
+  form: (resource: string, view: string, recordId?: string) => string;
   formField: (resource: string, view: string, fieldName: string) => string;
   formFieldInput: (resource: string, view: string, fieldName: string) => string;
   formFieldError: (resource: string, view: string, fieldName: string) => string;
   formFieldLocked: (resource: string, view: string, fieldName: string) => string;
+  /** A field leaf its user may not read the value of: the label and the restriction, no value. */
+  formFieldRestricted: (resource: string, view: string, fieldName: string) => string;
   /**
    * A field's help text — the hint under the input, resolved from the i18n
-   * `hint` slot or from `meta.description`.
+   * `fields.<name>.description` slot or from the field's description.
    *
    * ⚠️ This one was the other way round: the id was spelled identically on
-   * both sides and simply never rendered. `<ResourceForm>` drew the hint
+   * both sides and simply never rendered. the old record form drew the hint
    * paragraph with an `id` (for `aria-describedby`) and no `data-testid`, so
    * `form.field(x).help()` had matched nothing since it was written. The
    * producer was added at SP9 task 5, which is what lets a browser test assert
@@ -1754,6 +2584,8 @@ interface TestIdBuilder {
    * Auto-save / draft-found banner (B7.1). Rendered above the form's
    * field stack on mount when a non-stale localStorage draft exists.
    */
+  /** One option of the built-in type offer of a typed create (P1b+P1c decision 24). */
+  typeOffer: (resource: string, type: string) => string;
   formDraftBanner: (resource: string, view: string) => string;
   /** Restore button inside the draft banner (B7.1). */
   formDraftRestore: (resource: string, view: string) => string;
@@ -1788,13 +2620,28 @@ interface TestIdBuilder {
    * element inside it that does.
    *
    * The trigger takes the TARGET resource, not (resource, view, field): the
-   * component composes it from `to`. Inside a `<ResourceForm>` the trigger's
+   * component composes it from `to`. Inside a record form the trigger's
    * id is overridden with `formFieldInput(resource, view, field)` — the form
    * passes its own `testid` prop so a field's input is addressable the same
    * way whatever its kind — while every child of the popover keeps the
    * per-target prefix below. Both facts are asserted in that same test.
    */
   pickerTrigger: (targetResource: string) => string;
+  /**
+   * The select's "view" button (P6-28): the target resource and the form field that holds the key,
+   * `relation-view:<target>:<field>`.
+   */
+  relationView: (targetResource: string, field: string) => string;
+  /** The select's "+ create" button (P6-29): `relation-create:<target>:<field>`. */
+  relationCreate: (targetResource: string, field: string) => string;
+  /**
+   * What the select says in place of its options while it must not read (P7 3.4): which field to
+   * choose first, or that its candidates name a field the user may not see.
+   * `relation-candidates-hint:<resource>:<field>`.
+   */
+  relationCandidatesHint: (resource: string, field: string) => string;
+  /** A chip of a to-many select (P7 3.5): `relation-many-chip:<resource>:<field>:<id>`. */
+  relationManyChip: (resource: string, field: string, id: string) => string;
   /** The popover's search box. */
   pickerSearch: (targetResource: string) => string;
   /** The popover's result list (the popover content itself carries no id). */
@@ -1815,12 +2662,6 @@ interface TestIdBuilder {
   pickerDialogSearch: (targetResource: string) => string;
   /** The disabled trigger rendered when the target resource is unregistered. */
   pickerUnregistered: (targetResource: string) => string;
-  actionConfirmDialog: (resource: string, scope: string, actionName: string, recordId?: string) => string;
-  actionConfirmYes: (resource: string, scope: string, actionName: string) => string;
-  actionConfirmNo: (resource: string, scope: string, actionName: string) => string;
-  formModal: (resource: string, scope: string, actionName: string, recordId?: string) => string;
-  formModalSubmit: (resource: string, scope: string, actionName: string) => string;
-  formModalCancel: (resource: string, scope: string, actionName: string) => string;
   childrenTable: (resource: string, view: string, fieldName: string) => string;
   childrenRow: (resource: string, view: string, fieldName: string, index: number) => string;
   childrenAdd: (resource: string, view: string, fieldName: string) => string;
@@ -1867,20 +2708,6 @@ declare function useTestIds(): TestIdBuilder;
  */
 declare function useRecordTitle(resource: string | undefined, id: unknown, record?: unknown): string;
 //#endregion
-//#region src/hooks/use-action.d.ts
-interface UseActionResult {
-  run: () => Promise<void>;
-  isRunning: boolean;
-  error: Error | null;
-}
-interface UseActionArgs<TRecord, R extends ResourceHandle<any, any, any, any> = ResourceHandle<any, any, any, any>> {
-  resource: R;
-  record: TRecord;
-  values?: Partial<TRecord>;
-  dispatcher: Dispatcher;
-}
-declare function useAction<TRecord = unknown, R extends ResourceHandle<any, any, any, any> = ResourceHandle<any, any, any, any>>(action: Action<TRecord>, args: UseActionArgs<TRecord, R>): UseActionResult;
-//#endregion
 //#region src/hooks/use-task-run.d.ts
 /**
  * DRIVES ONE PIECE OF WORK AND KEEPS A {@link TaskRunReport} A VIEW CAN RENDER.
@@ -1893,8 +2720,8 @@ declare function useAction<TRecord = unknown, R extends ResourceHandle<any, any,
  *
  * That is deliberate and it is what makes this not an operations affordance.
  * The two callers this framework already has for it are a polled server-side
- * run and a client-side `for` loop over selected rows (`BulkActionHandler`
- * hand-rolls its own summary today) — nothing about a poll or a loop appears
+ * run and a client-side `for` loop over selected rows (a bulk flow has its own
+ * per-outcome summary since P4) — nothing about a poll or a loop appears
  * anywhere below.
  */
 /** What a running task tells the report. Handed to the task; never held afterwards. */
@@ -1964,6 +2791,16 @@ interface UseChecksOptions {
   readonly debounceMs?: number;
   readonly enabled?: boolean;
   readonly actionName?: string;
+  /**
+   * The screen's `with` sources the checks read, by name (P2 4.10). Pass a stable object: a
+   * new one re-runs the inline pass.
+   */
+  readonly sources?: Readonly<Record<string, SourceState>>;
+}
+/** The values one authoritative pass evaluates, when they are not the render's. */
+interface CheckPassValues {
+  readonly values: Record<string, unknown>;
+  readonly saved?: Record<string, unknown>;
 }
 interface UseChecksResult {
   readonly inlineIssues: ValidationIssues;
@@ -1977,89 +2814,28 @@ interface UseChecksResult {
    * empty because nothing was evaluated — a caller MUST NOT read that as
    * "nothing fired" and proceed. Check `outcome.aborted` before
    * `outcome.blockers`.
+   *
+   * `over` evaluates the given values (and saved record) instead of the ones
+   * this render passed: a submit decides on exactly the values it submits.
    */
-  readonly runNow: () => Promise<CheckOutcome>;
+  readonly runNow: (over?: CheckPassValues) => Promise<CheckOutcome>;
 }
 declare function useChecks(options: UseChecksOptions): UseChecksResult;
 //#endregion
-//#region src/checks/use-check-gate.d.ts
-interface CheckGateRequest {
-  readonly surface: CheckSurface;
-  readonly values?: Record<string, unknown>;
-  readonly saved?: Record<string, unknown>;
-  readonly record?: Record<string, unknown>;
-  readonly actionName?: string;
-  /** An existing `action.confirm` message; becomes the dialog header. */
-  readonly header?: string | null;
-}
-interface CheckGateState {
+//#region src/hooks/use-refresh.d.ts
+interface UseRefreshResult {
+  /** Invalidates every native data query and resolves once the active ones have refetched. */
+  readonly refresh: () => Promise<void>;
+  readonly isRefreshing: boolean;
   /**
-   * The resource whose checks this gate evaluates. Carried in the state so the
-   * dialog rendering it can bind its translations to the same resource the
-   * rules came from: a check message's i18n key is `checks.<id>`, which only
-   * reaches the per-resource entry `resources.<name>.checks.<id>` when a
-   * resource is bound.
-   *
-   * It must travel WITH the state rather than being passed to the dialog
-   * separately — the ambient `ResourceContext` is not a substitute. Only
-   * `<ResourceShow>` and `<ResourceForm>` mount one, so an action gated from a
-   * LIST ROW has no ambient resource at all, and the same check would render
-   * translated on a show page and untranslated in the list. (Exactly the bug
-   * `useResolvedLabel` in `action-button.tsx` carries a comment about.)
-   *
-   * Optional because a resource-less host — `<DeclarativeForm>` builds this
-   * shape by hand — genuinely has no resource to name.
+   * False without a native data runtime: there is nothing to refresh and `refresh` is a no-op.
+   * A bare `QueryClientProvider` does not count — only the data runtime's own query client holds
+   * the queries this hook invalidates.
    */
-  readonly resource?: string;
-  readonly open: boolean;
-  readonly busy: boolean;
-  readonly header: string | null;
-  readonly blockers: ValidationIssues;
-  readonly confirmable: ValidationIssues;
-  readonly proceed: () => void;
-  readonly cancel: () => void;
-}
-interface UseCheckGateResult {
-  readonly run: (request: CheckGateRequest) => Promise<'proceed' | 'cancel'>;
-  readonly state: CheckGateState;
-}
-/**
- * Imperative pre-flight gate. `run()` evaluates the resource's checks for the
- * surface, and resolves immediately with 'proceed' when there is nothing to say.
- * Otherwise it opens (the host renders the dialog off `state`) and resolves once
- * the user decides. One dialog: an existing `action.confirm` becomes its header
- * rather than a second prompt.
- */
-declare function useCheckGate(resource: string): UseCheckGateResult;
-//#endregion
-//#region src/hooks/use-bulk-action.d.ts
-interface UseBulkActionResult {
-  /** Resolves with the dispatched result, or `undefined` if the dispatch itself failed. */
-  run: () => Promise<ActionResult | undefined>;
-  isRunning: boolean;
-  error: Error | null;
-}
-interface UseBulkActionArgs<TRecord, R extends ResourceHandle<any, any, any, any> = ResourceHandle<any, any, any, any>> {
-  resource: R;
-  records: TRecord[];
-  /** Every selected id — see {@link BulkActionDI.ids}. */
-  ids: string[];
-  dispatcher: Dispatcher;
+  readonly available: boolean;
 }
-/**
- * Bulk variant of {@link useAction}. Wraps a `BulkActionHandler` so its
- * result flows through the host dispatcher's effects pipeline (notify,
- * clearSelection, refetch, redirect). Mirrors `useAction` API surface
- * (`{ run, isRunning, error }`) so call sites stay symmetric.
- *
- * The dispatcher's `Action` union doesn't currently include
- * `BulkActionHandler` (single-record vs bulk DI shape), but at runtime
- * both share `kind: 'handler'` and an identical handler-returning-result
- * contract. We cast at the dispatcher boundary so the runtime `kind`
- * guard still passes; the dispatcher itself doesn't read the DI shape
- * — handlers do — so the cast is sound.
- */
-declare function useBulkAction<TRecord = unknown, R extends ResourceHandle<any, any, any, any> = ResourceHandle<any, any, any, any>>(action: BulkActionHandler<TRecord>, args: UseBulkActionArgs<TRecord, R>): UseBulkActionResult;
+/** Refetches all data the app is showing: a header "Refresh" control, or any custom trigger. */
+declare function useRefresh(): UseRefreshResult;
 //#endregion
 //#region src/hooks/use-local-storage.d.ts
 /**
@@ -2082,14 +2858,17 @@ declare function useLocalStorage<T>(key: string, initial?: T): [T | undefined, (
 //#endregion
 //#region src/hooks/router/router-adapter.d.ts
 /**
- * The framework's whole dependency on a router.
+ * The framework's whole dependency on a router: where the app is and how to
+ * move. It is the router's only binding — route matching, the active nav item,
+ * breadcrumbs, URL state and every framework navigation read or write through
+ * it — and `LinkComponentProvider` only renders anchors. Mount it with
+ * `RouterAdapterProvider`.
  *
- * It exists because `@burojs/react` used to import `next/navigation`
- * directly, which made the package unusable outside Next for the sake of three
- * hooks. Links were already injected through `LinkComponentProvider`; this is
- * the same idea for location and navigation.
+ * Every member is app-space: `pathname` without the router's basename, and
+ * `push` / `replace` take a path the router prefixes itself.
  */
 interface RouterAdapter {
+  /** The current path, without the router's basename. */
   pathname: string;
   searchParams: URLSearchParams;
   /** Navigate without adding a history entry — used for URL-state sync. */
@@ -2100,8 +2879,77 @@ interface RouterAdapterProviderProps {
   adapter: RouterAdapter;
   children: React.ReactNode;
 }
+/**
+ * Binds your router to the framework. Required: mount it **above**
+ * `<BuroProvider>`, once for the whole app. Without it no route matches
+ * (`<NavAreaPage>` renders not-found and says so in development), no nav item
+ * is active, and every framework navigation falls back to a full page load.
+ * The default `redirect` and the navigation guard's "Leave" read the adapter
+ * from where `<BuroProvider>` sits, so one mounted inside it is invisible to
+ * them. `LinkComponentProvider` (`@burojs/ui-shadcn`) only renders anchors;
+ * it is not a router binding.
+ *
+ * react-router (v7; v6 exports the same hooks from `react-router-dom`):
+ *
+ * ```tsx
+ * import { RouterAdapterProvider } from '@burojs/react';
+ * import * as React from 'react';
+ * import { useLocation, useNavigate, useSearchParams } from 'react-router';
+ *
+ * export function ReactRouterAdapter({ children }: { children: React.ReactNode }) {
+ *   const location = useLocation();
+ *   const navigate = useNavigate();
+ *   const [searchParams] = useSearchParams();
+ *   const adapter = React.useMemo(
+ *     () => ({
+ *       pathname: location.pathname,
+ *       searchParams,
+ *       replace: (url: string) => navigate(url, { replace: true }),
+ *       push: (url: string) => navigate(url),
+ *     }),
+ *     [location.pathname, searchParams, navigate],
+ *   );
+ *   return <RouterAdapterProvider adapter={adapter}>{children}</RouterAdapterProvider>;
+ * }
+ * ```
+ *
+ * Next App Router (a client component):
+ *
+ * ```tsx
+ * 'use client';
+ * import { RouterAdapterProvider } from '@burojs/react';
+ * import { usePathname, useRouter, useSearchParams } from 'next/navigation';
+ * import * as React from 'react';
+ *
+ * export function NextRouterAdapter({ children }: { children: React.ReactNode }) {
+ *   const router = useRouter();
+ *   const pathname = usePathname();
+ *   const search = useSearchParams();
+ *   const adapter = React.useMemo(
+ *     () => ({
+ *       pathname,
+ *       searchParams: new URLSearchParams(search.toString()),
+ *       replace: (url: string) => router.replace(url, { scroll: false }),
+ *       push: (url: string) => router.push(url),
+ *     }),
+ *     [pathname, search, router],
+ *   );
+ *   return <RouterAdapterProvider adapter={adapter}>{children}</RouterAdapterProvider>;
+ * }
+ * ```
+ *
+ * Then: `<ReactRouterAdapter><BuroProvider app={app}>…</BuroProvider></ReactRouterAdapter>`.
+ */
 declare function RouterAdapterProvider({ adapter, children }: RouterAdapterProviderProps): React.ReactElement;
 declare function useRouterAdapter(): RouterAdapter;
+/**
+ * The router adapter, or `null` when none is mounted.
+ *
+ * `useRouterAdapter` throws by design — URL state that silently never persists
+ * is worse than a crash. Audit is the opposite case: an app with no router is
+ * legitimate, and auditing must never be the thing that breaks it.
+ */
+declare function useOptionalRouterAdapter(): RouterAdapter | null;
 //#endregion
 //#region src/hooks/use-debounced-value.d.ts
 /**
@@ -2308,6 +3156,11 @@ interface UseEnumValuesResult {
 declare function useEnumValues(enumName: string): UseEnumValuesResult;
 //#endregion
 //#region src/hooks/relation-aggregator.d.ts
+/**
+ * The most keys of one `by` read when the application declares no provider maximum: a batch asks
+ * for `2 × keys` rows, so it is read in chunks of half this many keys.
+ */
+declare const RELATION_BATCH_MAX_PAGE = 100;
 /**
  * A resolved relation record. Mirrors the shape used by the legacy
  * per-cell `useRelatedRecord` (see the deleted
@@ -2326,22 +3179,25 @@ interface UseRelatedRecordResult {
    * surfaces a per-id error (a dangling FK degrades to `record: undefined`
    * instead, matching today's fail-soft display behaviour). */
   error: Error | null;
+  /**
+   * True when the key matched more than one row of the target (a `by` key the backend does not
+   * keep unique): `record` stays undefined, the display renders the key muted, and one
+   * development error names the target, the field and the key. Never picks either row.
+   */
+  ambiguous: boolean;
 }
-interface RelationAggregatorProviderProps {
-  children?: ReactNode;
+/** Options of `useRelatedRecord`: the target field the key holds, and the display's resolve. */
+interface UseRelatedRecordOptions {
+  /** The target field the key is matched on; the target's id field when absent. */
+  readonly by?: string;
+  /** `'lazy'` registers nothing and reads nothing (spec 4.3); `'eager'` is the default. */
+  readonly resolve?: 'eager' | 'lazy';
 }
 /**
- * Mount once inside the native data runtime around the app
- * content. Every `useRelatedRecord` call underneath registers its id here
- * instead of holding its own react-query observer; this component renders
- * one `<ResourceBatch>` per resource that currently has un-resolved
- * registered ids.
- */
-declare function RelationAggregatorProvider({ children }: RelationAggregatorProviderProps): ReactElement;
-/**
- * Resolve a single record by `(targetResource, id)` for relation display.
+ * Resolve a single record by `(targetResource, key)` for relation display: by the target's id
+ * field, or by `options.by` (one batched `where <by> in [...]` list read per pair and flush).
  *
- * With a `<RelationAggregatorProvider>` mounted above: registers demand
+ * Under a `<BuroProvider>` with a data runtime (which mounts the aggregator): registers demand
  * (refcounted) and reads from the shared external store via
  * `useSyncExternalStore` — NO react-query observer per call. All calls for
  * the same resource on screen share ONE batched `getList(id in [...])`.
@@ -2355,52 +3211,16 @@ declare function RelationAggregatorProvider({ children }: RelationAggregatorProv
  * render; behaviour is selected by branching on VALUES (`store`, `idStr`),
  * never by skipping a hook call.
  */
-declare function useRelatedRecord(targetResource: string, id: string | number | null | undefined): UseRelatedRecordResult;
+declare function useRelatedRecord(targetResource: string, id: string | number | null | undefined, options?: UseRelatedRecordOptions): UseRelatedRecordResult;
 //#endregion
-//#region src/hooks/url-state/codec.d.ts
-type ResourceFilter = FilterExpression<ErasedResourceHandle>;
-type ResourceSort = SortExpression<ErasedResourceHandle>;
+//#region src/hooks/url-state/list-state-store.d.ts
 /**
- * Deliberate bounds for untrusted URL AST payloads. The values are large
- * enough for an interactive list, while preventing a pasted URL from making
- * server rendering or the first client render do unbounded recursive work.
+ * Where a list keeps its state (P1b+P1c decision 58): `'memory'`, which never touches the URL, or
+ * the URL under a namespace (`{ url: 'lines' }` writes `?lines.page=2`).
  */
-declare const RESOURCE_URL_STATE_LIMITS: {
-  readonly maxEncodedBytes: 16384;
-  readonly maxFilters: 50;
-  readonly maxFilterDepth: 16;
-  readonly maxFilterNodes: 200;
-  readonly maxSortEntries: 20;
+type ListState = 'memory' | {
+  readonly url: string;
 };
-/** Typed, router-independent state for an interactive resource list. */
-interface ResourceUrlState {
-  filters: readonly ResourceFilter[];
-  /** The builder group. `filters` above is the PINNED slot — always ANDed. */
-  filterGroup: FilterGroup;
-  sort: ResourceSort;
-  page: number;
-  pageSize: number;
-  search: string;
-  visibleColumns: string[] | null;
-}
-/**
- * Kept temporarily as a source-level migration seam for the list controller.
- * URL AST values preserve their JSON primitive type and no longer use this
- * hint for serialization or decoding.
- */
-type FieldType = 'string' | 'number' | 'boolean' | 'enum' | 'relation' | 'date';
-interface CodecOptions {
-  /** Resource key — used as the parameter namespace prefix. */
-  resource: string;
-  /** Values equal to these defaults are omitted from the URL. */
-  defaults: ResourceUrlState;
-  /** @deprecated AST envelopes preserve primitive value types directly. */
-  fieldTypes?: Record<string, FieldType>;
-}
-/** Serialize one resource's URL slice. AST state is versioned JSON/base64url. */
-declare function serializeResourceState(state: ResourceUrlState, opts: CodecOptions): URLSearchParams;
-/** Decode one resource's URL slice; malformed AST envelopes reset atomically. */
-declare function deserializeResourceState(params: URLSearchParams, opts: CodecOptions): ResourceUrlState;
 //#endregion
 //#region src/hooks/url-state/use-resource-url-state.d.ts
 /**
@@ -2485,7 +3305,7 @@ interface SetterOptions {
  *
  * Cross-resource isolation: params NOT prefixed with `<resource>.` are
  * preserved verbatim on every update. Two list views on the same page
- * (subresource tabs / embedded lists) can each call this hook for their
+ * (`related-list` placements in URL state) can each call this hook for their
  * own resource without colliding.
  *
  * Cold deep links: the initial render reads the router adapter's
@@ -2515,7 +3335,24 @@ interface SetterOptions {
 declare function useResourceUrlState(resource: string, opts?: {
   defaults?: Partial<ResourceUrlState>;
   fieldTypes?: Record<string, FieldType>;
+  /**
+   * Where the state lives: the URL under `?<resource>.` by default, the URL under another
+   * namespace (`{ url: 'lines' }`), or `'memory'`, which never writes the URL.
+   */
+  state?: ListState;
+  /**
+   * The list's field view (P5 spec 3.7): a filter, group leaf or sort entry naming a field for
+   * which `visible` is false is dropped when the state is read — before any chip or request —
+   * and from every write. Once `ready` (the list's decisions are settled) the address is
+   * rewritten without it, as a `replace`, through the same writer. Absent: nothing is dropped.
+   */
+  predicates?: {
+    readonly visible: (field: string) => boolean;
+    readonly ready: boolean;
+  };
 }): ResourceUrlState & {
+  /** How many predicates on hidden fields the address has carried and lost so far. */
+  droppedPredicates: number;
   setFilters: (filters: readonly FilterExpression<ErasedResourceHandle>[], options?: SetterOptions) => void;
   setFilterGroup: (group: FilterGroup, options?: SetterOptions) => void;
   setSort: (sort: ResourceUrlState['sort'], options?: SetterOptions) => void;
@@ -2747,6 +3584,13 @@ declare function useSavedViews(resource: string): UseSavedViewsResult;
  */
 interface ApplyViewToUrlStateOptions {
   defaults?: Omit<Partial<ResourceUrlState>, 'page'>;
+  /**
+   * The list's field view (P5 spec 3.7): a filter, group leaf or sort entry the view (or a
+   * default) carries on a field for which `visible` is false is dropped BEFORE any setter is
+   * called, so a view saved by a user who may see the field never writes its value into the
+   * address bar, history or a chip. Absent: nothing is dropped.
+   */
+  visible?: (field: string) => boolean;
 }
 /**
  * Subset of the `useResourceUrlState` return value the helper needs.
@@ -2810,7 +3654,9 @@ interface ApplyViewUrlStateSetters {
  * pageSize, search, visibleColumns). That keeps it trivially unit-testable
  * with a mock urlState.
  */
-declare function applyViewToUrlState(view: SavedViewDef, urlState: ApplyViewUrlStateSetters, options?: ApplyViewToUrlStateOptions): void;
+declare function applyViewToUrlState(view: SavedViewDef, urlState: ApplyViewUrlStateSetters, options?: ApplyViewToUrlStateOptions): {
+  readonly dropped: number;
+};
 //#endregion
 //#region src/hooks/command-palette/use-command-palette.d.ts
 /**
@@ -2875,122 +3721,57 @@ interface UseCommandPaletteOptions {
  */
 declare function useCommandPalette(opts?: UseCommandPaletteOptions): UseCommandPaletteResult;
 //#endregion
-//#region src/hooks/command-palette/use-track-recent-record.d.ts
-/**
- * Storage shape for one entry in the "recently visited" list.
- *
- * - `resource` — registry name of the resource (e.g. `document_document`).
- * - `id` — record id, always coerced to string for stable storage shape
- *   even when adopters use numeric ids.
- * - `label` — human-readable display label resolved at write time
- *   (alias → name → title → label → fallback to id). Captured at write
- *   so the Recent group survives even if the record is later deleted
- *   server-side; the navigation will 404 but the entry still renders
- *   and identifies which record it referenced.
- * - `visitedAt` — ISO timestamp of the most-recent visit. Updated on
- *   each call to `useTrackRecentRecord`.
- */
-interface RecentRecord {
-  resource: string;
-  id: string;
-  label: string;
-  visitedAt: string;
-}
+//#region src/flows/row-batch.d.ts
 /**
- * Persisted envelope. Mirrors the saved-views envelope (A4 pattern) so
- * future schema changes can bump `version` without crashing older tabs.
- *
- * Reads accept three shapes (see `parseRecentEnvelope`):
- *   1. Current v1 envelope `{ version: 1, items: RecentRecord[] }`.
- *   2. Legacy / defensive bare-array form (migrated on next write).
- *   3. Anything else / parse failure → treated as empty list.
+ * One row's record as the flows of a list page see it (plan ruling 15): `covered` — every ref the
+ * row flows' `when` and pre-click checks read is a field of the list DTO, so the list row is
+ * the record; `ready` — the page's one batched read returned this row (`row`); `pending` — that
+ * read has not answered for this id (or the id is not in the page's batch, Known finding 21).
  */
-interface RecentEnvelope {
-  version: 1;
-  items: RecentRecord[];
+interface FlowRowState {
+  readonly status: 'covered' | 'pending' | 'ready';
+  readonly row?: Row;
 }
 /**
- * Options for `useTrackRecentRecord`.
- */
-interface UseTrackRecentRecordOptions {
-  /**
-   * Maximum entries to keep. Default 5 (matches v0.2 spec C3.3). Older
-   * entries fall off the tail when a new one is upserted.
-   */
-  limit?: number;
-  /**
-   * Caller-supplied user id used as the localStorage key suffix. Multi-
-   * user installs pass `auth.user?.id`; single-user / unauthenticated
-   * adopters omit and share a `'singleton'` bucket.
-   *
-   * The framework's core `App` does not yet expose a built-in user
-   * slot (per the `AppContext` open interface — adopters declare their
-   * own `user` slice), so this is plumbed as an explicit option rather
-   * than read from `useApp()`. See `useApp` / `AppContext` for the
-   * declaration-merging extension point.
-   */
-  userId?: string | null;
-  isCurrentData?: boolean;
-}
-/**
- * Records a "recently visited" entry for the given `(resource, record)`
- * pair into `localStorage`.
- *
- * Storage contract:
- *   `localStorage["buro:recent:<userId|singleton>"]` →
- *     `JSON.stringify({ version: 1, items: RecentRecord[] })`
- *
- * Behaviour:
- *
- * - Fires on mount and re-fires whenever `record.id` changes — a
- *   single component instance navigating between two records still
- *   produces two entries.
- * - Dedupes by `(resource, id)`: revisiting the same record bumps its
- *   `visitedAt` and moves it to the front instead of creating a
- *   duplicate.
- * - FIFO-evicts the oldest entry when the list exceeds `limit`
- *   (default 5).
- * - Waits for a real record before writing — calling with
- *   `record === undefined | null` (typical loading state) is a no-op.
- * - SSR-safe: a missing `window` short-circuits before any storage
- *   call, so the hook is safe to import from server components.
- * - Storage write errors (quota / private mode) are swallowed silently;
- *   the palette continues to function with whatever the last successful
- *   write left behind.
- *
- * Companion reader: `getRecentRecords(userId)` is the synchronous
- * equivalent for the palette's Recent group — the palette re-reads on
- * every render (cheap; a localStorage read is sub-microsecond).
- *
- * Example:
- * ```tsx
- * function DocumentShowPage({ params }: { params: { id: string } }) {
- *   const { record } = useFetchRecord('document_document', params.id);
- *   useTrackRecentRecord('document_document', record);
- *   return <ResourceShow record={record} />;
- * }
- * ```
- */
-declare function useTrackRecentRecord(resource: string, record: {
-  id?: unknown;
-  [key: string]: unknown;
-} | null | undefined, opts?: UseTrackRecentRecordOptions): void;
-/**
- * Synchronous read of the Recent list for the given user. Safe to call
- * during render; SSR-safe (returns `[]` when `window` is undefined).
- *
- * Typical use: the palette's Recent group calls this on every render
- * to populate its rows. localStorage reads are sub-microsecond so the
- * cost is negligible; we don't subscribe to storage events.
- */
-declare function getRecentRecords(userId: string | null | undefined): RecentRecord[];
+ * The per-page batched pre-click read of a list (P4 spec 4.17, I8; plan ruling 15): one per
+ * list page, around its rows. When every ref the page's row flows read in `when` and their
+ * pre-click checks is a field of the list DTO, nothing is read and every row is `covered`;
+ * otherwise the page's ids are read in ONE `many` (the runtime's query key holds the session,
+ * the scope, the resource and the ids) and a row is `pending` until the read made for THIS page's
+ * ids answered for it (Known finding 21: another page's answer never decides a row). A `with`
+ * source is never read here: it loads at the click, or when a row menu opens.
+ */
+declare function useFlowRowBatch(resource: string, ids: readonly string[], flows: readonly CompiledFlow[]): {
+  readonly state: (id: string) => FlowRowState;
+  readonly reader: ReactElement | null;
+};
+/** @internal The list page's batch, for the row flows below it. */
+interface FlowRowBatchValue {
+  readonly resource: string;
+  readonly state: (id: string) => FlowRowState;
+}
+/** @internal Provided by the list page (`ResourceList`) around its rows. */
+declare const FlowRowBatchContext: import("react").Context<FlowRowBatchValue | null>;
+/** What a row (or a record surface without a run) shows for one flow, before any click. */
+interface FlowRowControl {
+  readonly state: FlowControlState;
+  readonly reason?: string;
+  /** The record the flow runs on: the batch's row when it read one, else the given row. */
+  readonly record?: Row;
+  /**
+   * Why an `absent` control is absent: the flow's gate (no oracle: indistinguishable from a flow
+   * that does not exist) or its own `when` over this record. A page-hosted flow's route answers
+   * the first with not-found and the second with "not available" (P6).
+   */
+  readonly cause?: 'gate' | 'when';
+}
 /**
- * Clear the Recent list for the given user. Used by adopters that want
- * to wire a "Clear recent" affordance (out of scope for v0.2 but cheap
- * to expose). Returns `true` when the key was removed (or already
- * absent), `false` when localStorage threw.
+ * @internal What a flow's control shows on a row, decided without a run and without a request
+ * (4.17, I8): the gate (undecided while permissions load), then the row's batch state (pending
+ * until the page's one read answered), then `when` and the pre-click checks over the row. A
+ * condition reading a `with` name is decided at click, when the run reads it.
  */
-declare function clearRecentRecords(userId: string | null | undefined): boolean;
+declare function useFlowRowResolver(resource: string): (name: string, record: Row | undefined) => FlowRowControl;
 //#endregion
 //#region src/hooks/use-item-actions.d.ts
 /**
@@ -3007,12 +3788,16 @@ interface ResolvedItemAction extends ItemActionPlacement {
   variant: 'default' | 'destructive';
   disabled: boolean;
   disabledReason?: string;
+  /**
+   * A flow (P4-C): its control as the row decides it before any click — the flow's gate, the
+   * page's batched read and its pre-click checks (`undecided` and `pending` render busy).
+   */
+  flow?: FlowRowControl;
 }
 declare const RENDER_TIME_DATA: ActionDataAccess;
 /**
- * Build a minimal ActionDI for evaluating action callbacks (link.to, modal.props,
- * confirm message, `visible`, etc.). Mirrors `useAction` but without dispatcher
- * coupling — link/modal kinds never hit the dispatcher.
+ * Build a minimal ActionDI for evaluating a link's `to` and a modal's `props` functions at
+ * render time.
  *
  * MOVED here from `@burojs/ui-shadcn`'s `action-button.tsx` (Task 6), which
  * defined this identically as a package-private function. `useItemActions` and
@@ -3160,9 +3945,12 @@ type FilterKind = {
 {
   kind: 'enum-values';
   values: readonly string[];
-} | {
+} |
+/** `by`: the target field the column holds (`meta.by`); options write its values. */
+{
   kind: 'relation';
   to: string;
+  by?: string;
 };
 /**
  * One filterable field as surfaced by `filters.available` — the
@@ -3220,7 +4008,34 @@ interface ResourceListController {
    */
   def: ResourceDef | undefined;
   /**
-   * The rows on screen, each coerced to {@link RowRecord}. Empty array
+   * The one list predicate (P5 spec 3.7): field view in any-record reach and `column` rules,
+   * decided with the record probe. `pending` while the permission map loads and a decision
+   * depends on it — the controller then offers no column, sends no read and reports loading.
+   */
+  access: ListAccess;
+  /**
+   * How many predicates on fields its user may not view the list dropped — from the address and
+   * from applied saved views (P5 spec 3.7). A host shows one notice while it is above zero.
+   */
+  droppedPredicates: number;
+  /**
+   * The read is forbidden (P5 spec 3.7): an author predicate (`fixedFilters`) or a function
+   * search names a field its user may not view. No request is sent; `rows` is empty and there is
+   * no total.
+   */
+  isForbidden: boolean;
+  /**
+   * A row as view code may read it (P5 spec 3.6.6, plan ruling 9): every field its user may not
+   * view for every row left out, the id kept; one object per row. {@link rows} are already
+   * projected this way; `viewRow` projects a row that came from elsewhere (a selected record, a
+   * row of a selection snapshot). Selection, bulk and item-action gates are policy and read the
+   * rows as read, which this hook keeps off its public type.
+   */
+  viewRow: (row: RowRecord) => RowRecord;
+  /**
+   * The rows on screen, each coerced to {@link RowRecord} and projected by its user's field
+   * access (P5 spec 3.6.6): a field the user may not view for every row is not on a row, so a
+   * list slot, a card grid or a custom body reading `rows` cannot draw it. Empty array
    * (never `undefined`) while loading or on a resource with no rows.
    * Moved from the `rows` memo, `_list-body.tsx:1310-1316`.
    *
@@ -3442,6 +4257,17 @@ interface ResourceListController {
     /** Free-text search box value (`_list-body.tsx`'s `search`). */
     search: string;
     setSearch: (query: string) => void;
+    /**
+     * The search declaration the list composes `search` with: the controller's `search` option
+     * (a placement's own search box), else the resource's `views.list.search`. An export and a
+     * count compose with it, so they describe the rows the list shows.
+     */
+    searchDecl?: SearchDecl;
+    /**
+     * Whether the list has a search for this user: a declared search set with every field its
+     * user may not view removed and none left is no search (P5 spec 3.7) — a host hides the box.
+     */
+    searchEnabled: boolean;
     /**
      * `true` when the search, any pinned filter, the builder group, or
      * {@link ResourceListController.providerQuery} is active. Moved from
@@ -3852,6 +4678,22 @@ interface UseResourceListOptions {
    * omit to use the declared value untouched.
    */
   refetchInterval?: number | false;
+  /**
+   * Where the list keeps its state (P1b+P1c decision 58): by default the URL under the
+   * resource's registry key (`?<resource>.page=2`), so bookmarks keep working; `{ url: prefix }`
+   * namespaces it under another prefix; `'memory'` never writes the URL (a list inside a custom
+   * block view, which must not write the record page's query string).
+   */
+  state?: ListState;
+  /**
+   * The default columns, in place of the target's `views.list.columns` (a `related-list`
+   * placement's `columns`). Column rules still apply.
+   */
+  columns?: readonly string[];
+  /** The default page size, in place of the target's `views.list.pageSize`. */
+  pageSize?: number;
+  /** The search, in place of the target's `views.list.search` (a placement's own search box). */
+  search?: SearchDecl;
 }
 /**
  * Data-connected list controller for `resource`.
@@ -3990,6 +4832,433 @@ declare function ResourceListProvider({ value, children }: ResourceListProviderP
  */
 declare function useResourceListContext(): ResourceListController;
 //#endregion
+//#region src/dispatch/dispatcher-context.d.ts
+interface DispatcherProviderProps {
+  /** Merged per key over the enclosing dispatcher's effects (over the defaults at the root). */
+  readonly effects?: Partial<DispatcherEffects>;
+  readonly children: ReactNode;
+}
+/**
+ * A nested dispatcher scope: `effects` merged per key over the enclosing
+ * dispatcher's. For a subtree that needs a different effect, and for tests that
+ * spy on effects. Must be rendered inside a `BuroProvider`.
+ */
+declare function DispatcherProvider({ effects, children }: DispatcherProviderProps): ReactElement;
+/** The nearest dispatcher. `BuroProvider` always mounts one. */
+declare function useDispatcher(): Dispatcher;
+/**
+ * @internal The effects the nearest dispatcher scope resolves to, read at call time: a nested
+ * scope that replaces one effect (a quick entry's `redirect`) passes what it does not handle to
+ * its parent's.
+ */
+declare function useDispatcherEffects(): () => DispatcherEffects;
+//#endregion
+//#region src/ui/present-block.d.ts
+/** What a modal action opens (P7 3.16): the block screen's props, in a dialog or a sheet. */
+interface PresentBlockInput extends BlockScreenProps {
+  readonly host: 'dialog' | 'sheet';
+  /** The activation the block is opened under; the ambient one when omitted. */
+  readonly activation?: Partial<ReturnType<typeof useCurrentUIActivation>>;
+}
+/**
+ * @internal Opens a modal action's block in the UI kit's `screens.block` (P7 3.16): the framework's
+ * own opener for the reserved `buro:block` key, which an app's `useUIPresent` refuses. The opener's
+ * dismiss scope becomes the overlay's parent, as for every overlay (P3-30), so closing a quick
+ * sheet asks about a dirty block above it. `{ ok: false }` when nothing could be presented.
+ */
+declare function usePresentBlock(): (input: PresentBlockInput) => UIPresentResult;
+//#endregion
+//#region src/navigation/resolve-route.d.ts
+/**
+ * Resolve a `RouteDescriptor` (string or object form) into an app-space URL.
+ *
+ * - string: returned as-is.
+ * - object: the target's canonical href via `hrefFor` (nesting-aware: a
+ *   resource behind nav groups lives at its group-prefixed path), plus every
+ *   non-id `param` in the query and `filters` encoded in the target list's
+ *   own URL format. An unregistered target keeps the literal `/<resource>…`
+ *   form, so a descriptor pointing outside the registry still resolves.
+ *
+ * The one resolver every navigation goes through: link actions, the
+ * dispatcher's default `redirect`, the record pages' navigation targets and
+ * the navigation guard's "leave".
+ */
+declare function resolveRoute(to: RouteDescriptor$1, registry?: AppRuntime['registry']): string;
+//#endregion
+//#region src/navigation/use-page-access.d.ts
+/**
+ * The decision about a page's `requires` (P7 3.13): `allowed` — the user holds the pair, or the
+ * page asks for none; `pending` — the permission map is absent or still loading, so nothing is
+ * decided and nothing may be read; `denied` — the map is decided and the user lacks the pair
+ * (a map that failed to load decides nothing in the user's favour either).
+ */
+type PageAccess = 'allowed' | 'pending' | 'denied';
+/**
+ * {@link usePageAccess} over a permission map. A page without `requires` is `allowed` whatever the
+ * map says. Fail closed: no map, or a map still loading, is `pending`.
+ */
+declare function pageAccessFor(page: {
+  readonly requires?: PageRequires | undefined;
+}, permissions: PermissionMap | undefined): PageAccess;
+/**
+ * Whether the current user may open `page` (P7 3.13). Every entry to a page (the sidebar, the
+ * palette, the group index), the route itself and a flow hosted on the page ask this one question,
+ * so a page the user cannot open has no entry and its route is the framework not-found.
+ */
+declare function usePageAccess(page: {
+  readonly requires?: PageRequires | undefined;
+}): PageAccess;
+//#endregion
+//#region src/flows/page-flow-gate.d.ts
+/**
+ * A flow with no record (an app flow, or a resource-level flow) as a page asks about it (P7
+ * 3.15): the flow compiled, and its gate (`resolveFlowGate`, P4 4.17) decided before anything is
+ * read — `undecided` while the permission map loads, `absent` for a flow that is not offered.
+ * `compiled` is `null` for a flow the application does not declare (fail closed: `absent`).
+ */
+interface PageFlowGate {
+  readonly answer: FlowGateAnswer;
+  readonly compiled: CompiledFlow | null;
+}
+/**
+ * The gate of a record-free flow. The same `resolveFlowGate` the app-action palette and the list
+ * toolbar run, so a page offers a flow exactly where they do.
+ */
+declare function usePageFlowGate(target: FlowTarget): PageFlowGate;
+//#endregion
+//#region src/flows/page-host.d.ts
+/** The page a flow's `host: { page }` names, when it names one (P7 3.15). */
+declare function hostPageRef(host: unknown): EntityRef | undefined;
+/** A flow's host page: where its buttons link, and whether the user may open it. */
+interface HostPage {
+  /** The page's own path (the flow's buttons are guarded links to it). */
+  readonly href: string;
+  readonly access: PageAccess;
+}
+/**
+ * The host page of a flow (P7 3.15), or `undefined` for a flow that is not hosted on one. A page
+ * no layer declares is `denied` (fail closed): the flow's buttons are absent rather than links to
+ * a not-found page. So is a page its own `visible`, or any group on its chain, hides: the route
+ * renders not-found for it (`PageHost`), so the link would land there.
+ */
+declare function hostPageFor(registry: RegistryReader, host: unknown, permissions: Parameters<typeof pageAccessFor>[1], ctx: AppContext): HostPage | undefined;
+/** {@link hostPageFor} for a component: the registry and the permission map from the context. */
+declare function useHostPage(host: unknown): HostPage | undefined;
+/**
+ * A flow control's state conjoined with its host page's access (P7 3.15): a page the user cannot
+ * open leaves no button (`absent`), an undecided one draws nothing yet (`undecided`).
+ */
+declare function conjoinHostPage(state: FlowControlState, hostPage: HostPage | undefined): FlowControlState;
+//#endregion
+//#region src/navigation/use-route-navigate.d.ts
+interface RouteNavigateOptions {
+  /** Navigate without adding a history entry. */
+  readonly replace?: boolean;
+}
+type RouteNavigate = (to: RouteDescriptor$1, options?: RouteNavigateOptions) => void;
+/**
+ * The framework's one navigation seam. Resolves a `RouteDescriptor` against the
+ * app registry and asks the navigation guard's gate (P1b+P1c decision 30):
+ * unblocked, or to the exact current URL, it navigates at once; with unsaved
+ * changes it holds the navigation for the guard's prompt. Outside a
+ * `NavigationGuardProvider` it navigates directly. Either way the navigation
+ * is the mounted `RouterAdapter`'s `push` (`replace` when asked), or a document
+ * navigation without one.
+ */
+declare function useRouteNavigate(): RouteNavigate;
+//#endregion
+//#region src/navigation/navigation-guard.d.ts
+/**
+ * Marks an anchor a quick opener owns (a relation display, a related-list row). The attribute
+ * alone changes nothing: the guard leaves a click to its opener only when the opener has also
+ * claimed the element (`quickAnchorRef`, internal), so an app's own `<a data-buro-quick>` is
+ * guarded like any link. A claimed anchor whose click the opener does not take (no
+ * `preventDefault`) is held by the guard after all, at the bubble phase.
+ */
+declare const QUICK_ANCHOR_ATTRIBUTE = "data-buro-quick";
+/**
+ * @internal The ref a framework quick opener puts on its anchor (with `QUICK_ANCHOR_ATTRIBUTE`):
+ * its click goes to the opener, which opens an overlay or navigates through the guarded gate.
+ */
+declare function quickAnchorRef(element: Element | null): void;
+interface NavigationGuardText {
+  readonly title: string;
+  readonly body: string;
+  readonly stay: string;
+  readonly leave: string;
+  /** Leave's label when the prompt holds a dismissal (`reason: 'dismiss'`). */
+  readonly discard: string;
+}
+/** The guard's strings: `navGuard.*` in the framework bundles, English literals without one. */
+declare function useNavigationGuardText(): NavigationGuardText;
+/**
+ * What the guard is holding, for the registered dialog to answer: a navigation (`href` is
+ * the app-space destination the user tried to reach) or the dismissal of an overlay holding
+ * a dirty form (`href` is `null`). Narrow on `reason`.
+ */
+type NavigationGuardPrompt = {
+  /**
+   * The labels of the active blockers that carry one (P6 3.12): an inline flow whose node is not
+   * on screen but holds unsaved input. The dialog says so after its text.
+   */
+  readonly labels: readonly string[];
+} & ({
+  readonly reason: 'navigation';
+  /** App-space destination the user tried to reach. */
+  readonly href: string;
+  /** Leave without saving: performs the deferred navigation. */
+  leave(): void;
+  /** Stay: drops the pending navigation. */
+  stay(): void;
+} | {
+  readonly reason: 'dismiss';
+  readonly href: null;
+  /** Discard: releases the overlay's forms and closes it with every overlay above it. */
+  leave(): void;
+  /** Stay: keeps every overlay open and gives focus back. */
+  stay(): void;
+});
+/**
+ * @internal Holds every route change while `active` (P4 plan ruling 7): a flow's pending lock
+ * spans the write, so a framework navigation or an in-app anchor click is dropped without a
+ * prompt (a development `console.info` names the hold) and `beforeunload` is armed. Registered
+ * in an effect, so a React StrictMode remount registers it again (Known finding 20).
+ */
+declare function useNavigationHold(active: boolean): void;
+/** What `useNavigationBlocker` takes besides `active`. */
+interface NavigationBlockerOptions {
+  /**
+   * Names what holds the unsaved input when its node is not on screen: the guard's dialog adds
+   * `navigation.unsavedAction` and the label (P6 3.12).
+   */
+  readonly label?: string;
+}
+/** What `useNavigationBlocker` returns. */
+interface NavigationBlockerHandle {
+  /** Unregister now, synchronously; the blocker registers again the next time `active` turns true. */
+  release(): void;
+}
+/**
+ * Arm the guard while the calling component holds unsaved changes (a dirty
+ * form). A no-op outside a `BuroProvider`. `release()` disarms it at once — a
+ * successful submit calls it before the navigation that follows, which must
+ * not wait for a render to unregister the blocker.
+ */
+declare function useNavigationBlocker(active: boolean, opts?: NavigationBlockerOptions): NavigationBlockerHandle;
+/**
+ * Register the calling component as the guard's leave dialog for as long as
+ * it is mounted, and return the navigation being held — to the CURRENT dialog
+ * only: the most recently registered one still mounted. Every other
+ * registrant gets `null`, so two dialogs (`<AppLayout>`'s and an explicit
+ * `<NavigationGuardDialog>`, say) never stack; unmounting the current one hands
+ * the prompt back to the previous registrant. With no dialog registered the
+ * guard asks through `window.confirm`.
+ */
+declare function useRegisterNavigationGuardDialog(): NavigationGuardPrompt | null;
+//#endregion
+//#region src/navigation/dismiss-scope.d.ts
+/**
+ * One overlay's dismiss scope: a presentation instance, a flow's host, the export
+ * dialog, or an app dialog under `useDismissGuard`. Scopes form a tree (P3-30): a dialog
+ * rendered inside an overlay is a child of the enclosing scope, and an overlay presented
+ * from inside another is a child of the scope it was presented from. A scope is dirty while
+ * any navigation blocker in it or in a descendant is active, and locked while any form in it
+ * or in a descendant submits.
+ */
+interface DismissScopeValue {
+  readonly id: string;
+  /**
+   * Ask before leaving: a locked scope ignores the request, a clean one calls `onLeave` at
+   * once, a dirty one holds it for the guard's prompt (Leave calls it, Stay drops it).
+   */
+  request(onLeave: () => void): void;
+  /** True while a form in this scope or a descendant scope submits. */
+  isLocked(): boolean;
+}
+/**
+ * Provide `value` as the dismiss scope of everything below: the forms rendered inside register
+ * their unsaved-changes blockers and their submitting state in it.
+ */
+declare function DismissGuardScope({ value, children }: {
+  readonly value: DismissScopeValue;
+  readonly children: ReactNode;
+}): ReactElement;
+/** What `useDismissGuard` returns. */
+interface DismissGuard {
+  /** Close through the guard: asks first when a form in the scope (or below it) is dirty. */
+  dismiss(): void;
+  /** Pass to `<DismissGuardScope value={…}>` around the dialog's content. */
+  readonly scope: DismissScopeValue;
+}
+/**
+ * Guard an app's own dialog against losing a dirty form (P3-33): wrap its content in
+ * `<DismissGuardScope value={guard.scope}>` and route its close through `guard.dismiss()`.
+ * Outside a `BuroProvider` `dismiss()` calls `onDismiss` at once.
+ *
+ * ```tsx
+ * const guard = useDismissGuard(() => setOpen(false));
+ * <Dialog open={open} onOpenChange={(next) => { if (!next) guard.dismiss(); }}>
+ *   <DismissGuardScope value={guard.scope}><MyForm /></DismissGuardScope>
+ * </Dialog>
+ * ```
+ */
+declare function useDismissGuard(onDismiss: () => void): DismissGuard;
+/**
+ * @internal Lock the enclosing dismiss scope while `pending` is true: a submitting form's
+ * overlay ignores Escape, an outside click and ✕ (P3-34). A no-op outside a scope.
+ */
+declare function useDismissPending(pending: boolean): void;
+//#endregion
+//#region src/flows/open-implementation.d.ts
+/**
+ * @internal The app's view of the block a flow's `then.open` names (P4 spec 4.13), by its
+ * `<namespace>:<name>` id, from the catalog mounted in `<BuroProvider blockImplementations>`;
+ * `undefined` when the app implements none (the UI kit falls back to its own).
+ */
+declare function useFlowOpenImplementation(id: string): BlockImplementation<unknown> | undefined;
+//#endregion
+//#region src/flows/resource-flows.d.ts
+/** The surfaces a resource-level flow can be drawn on, besides the record ones (P7-31). */
+type ResourceFlowSurface = 'list';
+/**
+ * The resource-level flows (`actions.resource`) a resource draws on `surface`, in the order its
+ * toolbar shows them: `order` first (ascending; a flow without one keeps its declaration
+ * position among the unordered), then declaration order. A flow whose `surfaces` resolve to
+ * `false` on `surface` is left out; the rest are `'menu'` or a prominent mode.
+ */
+declare function resourceFlowsOn(def: Pick<ResourceDef, 'actions'>, surface: ResourceFlowSurface): readonly ActionFlow[];
+//#endregion
+//#region src/flows/present-flow.d.ts
+interface PresentFlowInput extends FlowStart {
+  readonly host: 'dialog' | 'sheet';
+  readonly label: string;
+  readonly title?: string;
+}
+/**
+ * @internal Opens a flow with a form or a review in the UI kit's host (P4 spec 4.15; P4-C review
+ * I1): the host owns the run, so it outlives the control that opened it — a dirty form still
+ * asks before it closes, and a pending write is never cut. The opener's dismiss scope is the
+ * host's parent (closing a quick sheet asks about a dirty flow above it) and the opener's
+ * dispatcher scope runs `then`. Resolves when the host closes, with the last outcome (`halted`
+ * when there was none); `null` when nothing could be presented (one development error names a
+ * missing host or screen).
+ */
+declare function usePresentFlow(): (input: PresentFlowInput) => Promise<FlowResult> | null;
+//#endregion
+//#region src/quick/use-quick.d.ts
+/** What a quick open did: opened, opened nothing (with a development error), or waited for access. */
+type QuickOpen = 'opened' | 'absent' | 'undecided';
+/**
+ * Opening a record in an overlay from code (spec 3.5). Every call runs the same entry gate as the
+ * framework's openers; `'absent'` and `'undecided'` open nothing, and an undecided call is never
+ * queued.
+ */
+interface QuickApi {
+  show(resource: ResourceRefInput, id: string | number): QuickOpen;
+  edit(resource: ResourceRefInput, id: string | number): QuickOpen;
+  /**
+   * Opens `quick.create`; resolves with the created row, or `null` when the gate refused it or
+   * the overlay closed without one. `defaults` are the caller's trusted tier; `input` is user
+   * input (a search text the user typed): it fills the fields the create form holds active and
+   * editable for this user, makes the form dirty, and is dropped for any other field.
+   */
+  create(resource: ResourceRefInput, opts?: {
+    readonly defaults?: Readonly<Record<string, unknown>>;
+    readonly input?: Readonly<Record<string, unknown>>;
+  }): Promise<QuickSettledRow>;
+}
+/**
+ * The one way to open a record in an overlay from code. `show` / `edit` with an id that is no
+ * key (`null`, `''`, `NaN`, an object, a boolean) open nothing and log a development error, as
+ * does a refused entry; `'undecided'` (the permission map is loading) opens nothing and is never
+ * queued. A `show` of the record already on top of the topmost quick sheet opens nothing more.
+ */
+declare function useQuick(): QuickApi;
+/**
+ * @internal The framework openers' path to `quick.show` (a relation display, a related-list
+ * row): the gate with the opener's row, then — inside a quick sheet, a push through the sheet's
+ * scope (it asks when the sheet holds a dirty form); inside a quick dialog, the dialog closes
+ * (through its scope) and the target opens as a new overlay beside it; elsewhere a new overlay
+ * whose parent is the enclosing scope.
+ */
+declare function useQuickOpener(): (target: string, id: string, opts?: {
+  readonly row?: unknown;
+}) => QuickOpen;
+//#endregion
+//#region src/quick/quick-entry-context.d.ts
+/** What a component inside a quick overlay knows about it. */
+interface QuickEntryValue {
+  readonly stack: QuickStack;
+  readonly host: QuickHost;
+  /** The overlay's presentation id in the runtime. */
+  readonly presentationId: string;
+  /** The overlay's dismiss scope: a push or a close inside it asks through it. */
+  readonly scope: DismissScopeValue;
+}
+/** @internal Provided by the UI kit's quick screen around the entry it renders. */
+declare const QuickEntryContext: Context<QuickEntryValue | null>;
+/** The quick overlay the caller renders in, or `null` outside one. */
+declare function useQuickEntry(): QuickEntryValue | null;
+/**
+ * @internal What the UI kit's quick screen provides as `QuickEntryContext`: its stack, the host it
+ * was presented in (read off its descriptor), its presentation id and the presentation's dismiss
+ * scope. Called by the quick screen, which renders inside its presentation instance.
+ */
+declare function useQuickEntryValue(stack: QuickStack): QuickEntryValue;
+//#endregion
+//#region src/quick/entry-gate.d.ts
+/** Which entry an opener asks for: a quick entry's mode, or the peek. */
+type EntryKind = 'show' | 'edit' | 'create' | 'peek';
+/**
+ * The entry gate's answer (spec 4.4). `open` names the host and the resolved target (a resource
+ * delegating its show through `routesTo.show` opens the delegate's entry). `undecided` while the
+ * user's permission map loads: the opener renders plain text and sends nothing. `absent`, `hidden`
+ * and `disabled` open nothing, and say why.
+ */
+type EntryAnswer = {
+  readonly state: 'open';
+  readonly host: UIPresentHost;
+  readonly target: string;
+} | {
+  readonly state: 'undecided';
+} | {
+  readonly state: 'absent' | 'hidden' | 'disabled';
+  readonly why: string;
+};
+/**
+ * @internal The one entry gate every opener asks before any request (spec 4.4, 4.14):
+ *
+ *  1. static — the target resolves (following `routesTo.show` for `show` and `peek`),
+ *     `recordEntries` names the entry, and its host and screen are wired in
+ *     `presentationHosts`; otherwise `absent` (one development error per missing member);
+ *  2. decided — `undecided` while the permission map has `status: 'loading'`. No map is
+ *     decided, and a map in `error` is decided by the rules (a `can()` against it fails closed);
+ *  3. dynamic — `resolveAvailability` of the entry's operation (`show` for the peek) with the
+ *     opener's row when it holds one.
+ */
+declare function useEntryGate(): (target: string, entry: EntryKind, row?: unknown) => EntryAnswer;
+//#endregion
+//#region src/notifications/notification-sink.d.ts
+interface NotificationSinkMessage {
+  /** `info` is a plain notice that dismisses itself, never a progress indicator. */
+  readonly type: 'success' | 'error' | 'info';
+  readonly message: string;
+  readonly description?: string;
+}
+/** Where the dispatcher's default `notify` delivers — a UI kit's toaster. */
+interface NotificationSink {
+  open(notification: NotificationSinkMessage): void;
+}
+/**
+ * Register `sink` for as long as the calling component is mounted. Outside a
+ * `BuroProvider` it registers nothing and throws nothing, so a toaster mounted
+ * at an app root keeps working standalone.
+ *
+ * `sink` must be stable (memoised, e.g. with `useMemo`): it is an effect
+ * dependency, so an inline object re-registers on every render.
+ */
+declare function useRegisterNotificationSink(sink: NotificationSink | null): void;
+//#endregion
 //#region src/merge-components.d.ts
 /**
  * Shallow merge of components objects. Overrides keys win; both inputs unchanged.
@@ -4000,7 +5269,7 @@ declare function mergeComponents<TBase extends Record<string, unknown>, TOver ex
 /** A resource's list/show/edit/create route. */
 interface ResourceRouteDescriptor {
   resource: string;
-  action: 'list' | 'show' | 'edit' | 'create';
+  action: 'list' | 'show' | 'edit' | 'create' | 'flow';
   path: string;
 }
 /** A custom (non-resource) page's single route. */
@@ -4041,6 +5310,44 @@ declare const en: {
   readonly validation: {
     readonly requiredHint: "(required)";
     readonly required: "This field is required";
+    readonly string: {
+      readonly minLength: "Too short";
+      readonly maxLength: "Too long";
+      readonly pattern: "Invalid format";
+    };
+    readonly constraint: {
+      readonly invalid: "Invalid value";
+    };
+    readonly number: {
+      readonly minimum: "Value is too small";
+      readonly maximum: "Value is too large";
+      readonly exclusiveMinimum: "Value is too small";
+      readonly exclusiveMaximum: "Value is too large";
+      readonly multipleOf: "Value is not an allowed step";
+    };
+    readonly array: {
+      readonly minItems: "Too few items";
+      readonly maxItems: "Too many items";
+      readonly uniqueItems: "Items must be unique";
+    };
+    readonly validator: {
+      readonly invalid: "Invalid value";
+      readonly exception: "Validation failed";
+    };
+    readonly schema: {
+      readonly invalid: "Invalid value";
+      readonly exception: "Validation failed";
+    };
+    readonly resource: {
+      readonly invalid: "Invalid value";
+    };
+    readonly type: {
+      readonly string: "Must be text";
+      readonly number: "Must be a number";
+      readonly boolean: "Must be yes or no";
+      readonly array: "Must be a list";
+      readonly object: "Must be an object";
+    };
   };
   readonly actions: {
     readonly close: "Close";
@@ -4069,7 +5376,10 @@ declare const en: {
   };
   readonly confirm: {
     readonly delete: "Are you sure you want to delete?";
-    readonly deleteMany: "Are you sure you want to delete {{count}} records?";
+    readonly deleteMany_one: "Are you sure you want to delete {{count}} record?";
+    readonly deleteMany_few: "Are you sure you want to delete {{count}} records?";
+    readonly deleteMany_many: "Are you sure you want to delete {{count}} records?";
+    readonly deleteMany_other: "Are you sure you want to delete {{count}} records?";
     readonly discardChanges: "Discard unsaved changes?";
     readonly ok: "OK";
     readonly confirm: "Confirm";
@@ -4079,22 +5389,24 @@ declare const en: {
     readonly proceed: "Continue anyway";
     readonly back: "Go back";
     readonly blocked: "Cannot continue";
-    readonly exception: "A check failed to run";
+    readonly couldNotVerify: "Could not verify \"{{checkId}}\"";
+    readonly notVerified: "Check \"{{checkId}}\" failed to run";
     readonly parseError: "Check \"{{checkId}}\" has an invalid condition: {{detail}}";
   };
   readonly table: {
-    readonly selectedCount: "{{count}} selected";
+    readonly selectedCount_one: "{{count}} selected";
+    readonly selectedCount_few: "{{count}} selected";
+    readonly selectedCount_many: "{{count}} selected";
+    readonly selectedCount_other: "{{count}} selected";
     readonly empty: "No records";
     readonly loading: "Loading…";
-    readonly rowsSelected: "{{count}} selected";
+    readonly rowsSelected_one: "{{count}} selected";
+    readonly rowsSelected_few: "{{count}} selected";
+    readonly rowsSelected_many: "{{count}} selected";
+    readonly rowsSelected_other: "{{count}} selected";
     readonly selectAllRows: "Select all rows";
     readonly selectRow: "Select row";
   };
-  readonly show: {
-    readonly groups: {
-      readonly other: "Other";
-    };
-  };
   readonly boolean: {
     readonly yes: "Yes";
     readonly no: "No";
@@ -4149,7 +5461,10 @@ declare const en: {
     readonly clear: "Clear";
     readonly reset: "Reset";
     readonly title: "Filters";
-    readonly selectedCount: "{{count}} selected";
+    readonly selectedCount_one: "{{count}} selected";
+    readonly selectedCount_few: "{{count}} selected";
+    readonly selectedCount_many: "{{count}} selected";
+    readonly selectedCount_other: "{{count}} selected";
     readonly is: "is";
     readonly isNot: "is not";
     readonly contains: "contains";
@@ -4169,11 +5484,12 @@ declare const en: {
   readonly errors: {
     readonly required: "Required";
     readonly invalid: "Invalid value";
-    readonly tooLong: "No more than {{max}} characters";
-    readonly tooShort: "At least {{min}} characters";
     readonly failed: "Validation failed";
     readonly validatorFailed: "Could not validate the form. Please try again.";
   };
+  readonly access: {
+    readonly restricted: "No access";
+  };
   readonly list: {
     readonly loadingShort: "Loading…";
     readonly notRegistered: "Resource not registered";
@@ -4183,19 +5499,19 @@ declare const en: {
     readonly errorDetails: "Details";
     readonly emptyTitle: "No {{items}} yet";
     readonly emptyBody: "Get started by creating your first {{item}}.";
+    readonly emptyBodyReadOnly: "They will appear here once they are added.";
     readonly emptyFilteredTitle: "No matching {{items}}";
     readonly emptyFilteredBody: "No {{items}} match the current filter. Try clearing the filter to see everything.";
     readonly clearFilter: "Clear filter";
     readonly create: "+ Create {{item}}";
     readonly templateUnknown: "Unknown";
     readonly search: "Search";
+    readonly predicatesDropped: "Some saved filters were not applied";
+    readonly flowsMenu: "More actions";
   };
-  readonly tab: {
-    readonly details: "Details";
-  };
-  readonly tabBody: {
-    readonly empty: "Nothing to show here yet.";
-    readonly failed: "This tab failed to load.";
+  readonly timeline: {
+    readonly empty: "No entries";
+    readonly undated: "Undated";
   };
   readonly breadcrumbs: {
     readonly create: "Create";
@@ -4206,10 +5522,25 @@ declare const en: {
     readonly resources: "Resources";
     readonly main: "Main navigation";
     readonly breadcrumb: "Breadcrumb";
-    readonly language: "Language";
     readonly toggleSidebar: "Toggle sidebar";
     readonly label: "Navigation";
   };
+  readonly shell: {
+    readonly refresh: "Refresh";
+    readonly help: "Help";
+    readonly scopeSwitcher: "Switch";
+    readonly scopePlaceholder: "Select…";
+    readonly account: "Account";
+  };
+  readonly theme: {
+    readonly label: "Theme";
+    readonly light: "Light";
+    readonly dark: "Dark";
+    readonly system: "System";
+  };
+  readonly language: {
+    readonly label: "Language";
+  };
   readonly pageHeader: {
     readonly backTo: "Back to {{label}}";
     readonly editTitle: "Edit {{label}}";
@@ -4221,6 +5552,10 @@ declare const en: {
     readonly emptyBody: "This page has no registered content.";
     readonly notFoundTitle: "Page not found";
     readonly notFoundBody: "This route doesn't match any registered page.";
+    readonly recordLoading: "Loading…";
+    readonly recordNotFound: "This record does not exist, or you do not have access to it.";
+    readonly recordSessionExpired: "Your session has expired. Sign in again to continue.";
+    readonly recordError: "The record could not be loaded.";
   };
   readonly notifications: {
     readonly region: "Notifications";
@@ -4230,6 +5565,13 @@ declare const en: {
     readonly unsupportedType: "Unsupported type";
     readonly unsupportedTypeHint: "The type “{{type}}” is not registered for this resource.";
     readonly backToPicker: "Back to picker";
+    /** The built-in type offer of a typed create (P1b+P1c decision 24). */
+    readonly typeOffer: {
+      readonly title: "Choose a type";
+      readonly hint: "The type decides which fields the record has.";
+      readonly empty: "No type can be created here.";
+      readonly change: "Change type";
+    };
   };
   readonly taskRun: {
     readonly idle: "Not started";
@@ -4253,7 +5595,10 @@ declare const en: {
   };
   readonly toolbar: {
     readonly clearAll: "Clear all";
-    readonly clearAllAria: "Clear {{count}} active filters";
+    readonly clearAllAria_one: "Clear {{count}} active filter";
+    readonly clearAllAria_few: "Clear {{count}} active filters";
+    readonly clearAllAria_many: "Clear {{count}} active filters";
+    readonly clearAllAria_other: "Clear {{count}} active filters";
     readonly addFilter: "Add filter";
     readonly filterBy: "Filter by";
     readonly columns: "Columns";
@@ -4290,6 +5635,7 @@ declare const en: {
     readonly liveOff: "Auto-refresh: off";
   };
   readonly field: {
+    readonly misconfigured: "This field is misconfigured";
     readonly removeFile: "Remove file";
     readonly pickFile: "Pick or drop a file";
     readonly dropHint: "Click to pick a file or drag-and-drop";
@@ -4301,12 +5647,13 @@ declare const en: {
   readonly form: {
     readonly systemFields: "System fields (read-only)";
     readonly validating: "Validating";
-    readonly wizardProgress: "Wizard progress";
   };
   readonly relation: {
     readonly select: "Select {{name}}…";
     readonly failed: "Failed to load options.";
     readonly noResults: "No results.";
+    /** A lazy `by` relation whose key names no row, found when it is clicked (P3). */
+    readonly unavailable: "Not available";
   };
   readonly columnMenu: {
     readonly sortSection: "Sort";
@@ -4327,13 +5674,23 @@ declare const en: {
     readonly body: "You have unsaved changes on this page. If you leave now, they will be lost.";
     readonly stay: "Stay";
     readonly leave: "Leave without saving";
+    readonly discard: "Discard changes";
+  };
+  readonly navigation: {
+    readonly unsavedAction: "An action on this screen has unsaved input";
   };
   readonly relationPicker: {
     readonly viewAll: "Open list";
     readonly clear: "Clear";
     readonly advancedSearch: "Advanced search";
     readonly title: "Select: {{name}}";
-    readonly create: "Create";
+    readonly view: "View";
+    readonly create: "+ Create";
+    readonly createdNotFitting: "The record was created but does not fit this field";
+    readonly createdNotSelected: "The record was created but could not be selected";
+    readonly chooseFirst: "Choose {{label}} first";
+    readonly cannotSearchBy: "You cannot search by {{label}}";
+    readonly notMatching: "Does not match the current filter";
     readonly select: "Select";
     readonly prev: "Prev";
     readonly next: "Next";
@@ -4344,10 +5701,20 @@ declare const en: {
     readonly restorePrompt: "Restore?";
     readonly restore: "Restore";
     readonly discard: "Discard";
+    readonly recordChanged: "Record changed since your draft";
     readonly timeAgoMoment: "a moment ago";
-    readonly timeAgoMinutes: "{{n}} minutes ago";
-    readonly timeAgoHours: "{{n}} hours ago";
-    readonly timeAgoDays: "{{n}} days ago";
+    readonly timeAgoMinutes_one: "{{count}} minute ago";
+    readonly timeAgoMinutes_few: "{{count}} minutes ago";
+    readonly timeAgoMinutes_many: "{{count}} minutes ago";
+    readonly timeAgoMinutes_other: "{{count}} minutes ago";
+    readonly timeAgoHours_one: "{{count}} hour ago";
+    readonly timeAgoHours_few: "{{count}} hours ago";
+    readonly timeAgoHours_many: "{{count}} hours ago";
+    readonly timeAgoHours_other: "{{count}} hours ago";
+    readonly timeAgoDays_one: "{{count}} day ago";
+    readonly timeAgoDays_few: "{{count}} days ago";
+    readonly timeAgoDays_many: "{{count}} days ago";
+    readonly timeAgoDays_other: "{{count}} days ago";
     readonly timeAgoRecently: "recently";
   };
   readonly commandPalette: {
@@ -4431,10 +5798,16 @@ declare const en: {
       };
     };
     readonly dialog: {
-      readonly titleFilter: "Export {{count}} rows by current filter";
+      readonly titleFilter_one: "Export {{count}} row by current filter";
+      readonly titleFilter_few: "Export {{count}} rows by current filter";
+      readonly titleFilter_many: "Export {{count}} rows by current filter";
+      readonly titleFilter_other: "Export {{count}} rows by current filter";
       /** `estimatedCount` is optional on `ExportDialogProps` — shown when a filter-scope export has no known row estimate. */
       readonly titleFilterUnknownCount: "Export rows by current filter";
-      readonly titleSelected: "Export {{count}} selected rows";
+      readonly titleSelected_one: "Export {{count}} selected row";
+      readonly titleSelected_few: "Export {{count}} selected rows";
+      readonly titleSelected_many: "Export {{count}} selected rows";
+      readonly titleSelected_other: "Export {{count}} selected rows";
       /** Defensive fallback: Task 8 gates the trigger on `available` before opening, so this is only reachable from a direct/programmatic mount. */
       readonly unavailable: "Export is not available for this resource.";
       /** Shown in place of the format selector while a deferred exporter registration (`ExporterLoader`) is still loading. */
@@ -4470,6 +5843,94 @@ declare const en: {
   readonly notify: {
     readonly deleted: "Record deleted";
   };
+  readonly record: {
+    readonly copyId: "Copy ID";
+  };
+  /** A quick overlay's header (P3): Back to the previous entry, close, open the record's page. */
+  readonly quick: {
+    readonly back: "Back to {{title}}";
+    readonly close: "Close";
+    readonly openAsPage: "Open as page";
+  };
+  /** A peek: the hover preview of a related record (P3). */
+  readonly peek: {
+    readonly failed: "Couldn't load";
+    readonly unavailable: "Not available";
+  };
+  /** A block placement's framework chrome (P1b+P1c section 8.1). */
+  readonly block: {
+    readonly failed: "This section could not be loaded.";
+    readonly sessionExpired: "Your session has expired. Sign in again to continue.";
+    readonly notImplemented: "This section is not available.";
+  };
+  readonly facts: {
+    readonly empty: "No data";
+  };
+  readonly screen: {
+    readonly failed: "This section could not be loaded.";
+    /** A tab's, step's or collapsed panel's badge: errors, not fields. */
+    readonly errorCount_one: "{{count}} error";
+    readonly errorCount_few: "{{count}} errors";
+    readonly errorCount_many: "{{count}} errors";
+    readonly errorCount_other: "{{count}} errors";
+    readonly expand: "Expand";
+    readonly collapse: "Collapse";
+  };
+  /** A create wizard (a `steps` node in create). */
+  readonly steps: {
+    readonly progress: "Progress";
+    readonly next: "Next";
+    readonly back: "Back";
+    readonly current: "Step {{index}} of {{count}}";
+  };
+  /** A flow's host and outcomes (P4 spec 4.22). */
+  readonly flow: {
+    readonly submit: "Submit";
+    readonly back: "Back";
+    readonly next: "Next";
+    readonly checkAgain: "Check again";
+    readonly close: "Close";
+    readonly resend: "Resend";
+    readonly sendAsNew: "Send as new";
+    readonly sendAsNewConfirm: "This may apply the change twice. Send it as a new request?";
+    readonly startOver: "I've checked — start over";
+    readonly forget: "I've checked — forget it";
+    readonly couldNotCheck: "Couldn't check";
+    readonly couldNotReread: "Couldn't re-read the record. Nothing was sent.";
+    readonly unavailable: "Not allowed.";
+    readonly busyElsewhere: "This action is running in another tab.";
+    readonly notAvailable: "This action is not available";
+    readonly noLongerApplies: "This action no longer applies";
+    readonly discard: "Discard";
+    readonly done: "Done";
+    readonly reset: "Reset";
+    readonly rejected: {
+      readonly validation: "The server refused the values. Nothing was saved.";
+      readonly conflict: "Someone else changed this record. Nothing was saved.";
+      readonly forbidden: "You are not allowed to do this. Nothing was saved.";
+      readonly notFound: "This record is no longer available.";
+      readonly precondition: "The record changed. Nothing was sent.";
+      readonly gone: "This record is no longer available.";
+    };
+    readonly failed: "The request could not be sent. Nothing was saved.";
+    readonly unknown: "The request timed out. It may have been applied. Nothing was resent.";
+    readonly unknownUnhandled: "Check the record before trying again.";
+    readonly resultUnavailable: "Done; the result is not available here.";
+    readonly bulkSummary_one: "{{count}} record processed";
+    readonly bulkSummary_few: "{{count}} records processed";
+    readonly bulkSummary_many: "{{count}} records processed";
+    readonly bulkSummary_other: "{{count}} records processed";
+    readonly bulkLimit_one: "Select at most {{count}} record.";
+    readonly bulkLimit_few: "Select at most {{count}} records.";
+    readonly bulkLimit_many: "Select at most {{count}} records.";
+    readonly bulkLimit_other: "Select at most {{count}} records.";
+    readonly bulkUnresolved: "Skipped: an earlier request for it may have been applied.";
+    readonly bulkNotAttempted: "Not attempted.";
+  };
+  /** A flow's review step (P4 spec 4.4). */
+  readonly review: {
+    readonly changed: "changed";
+  };
 };
 //#endregion
 //#region src/locales/ru.d.ts
@@ -4477,6 +5938,44 @@ declare const ru: {
   readonly validation: {
     readonly requiredHint: "(обязательное)";
     readonly required: "Обязательное поле";
+    readonly string: {
+      readonly minLength: "Слишком короткое значение";
+      readonly maxLength: "Слишком длинное значение";
+      readonly pattern: "Неверный формат";
+    };
+    readonly constraint: {
+      readonly invalid: "Неверное значение";
+    };
+    readonly number: {
+      readonly minimum: "Слишком маленькое значение";
+      readonly maximum: "Слишком большое значение";
+      readonly exclusiveMinimum: "Слишком маленькое значение";
+      readonly exclusiveMaximum: "Слишком большое значение";
+      readonly multipleOf: "Недопустимый шаг значения";
+    };
+    readonly array: {
+      readonly minItems: "Слишком мало элементов";
+      readonly maxItems: "Слишком много элементов";
+      readonly uniqueItems: "Элементы должны быть уникальными";
+    };
+    readonly validator: {
+      readonly invalid: "Неверное значение";
+      readonly exception: "Проверка не пройдена";
+    };
+    readonly schema: {
+      readonly invalid: "Неверное значение";
+      readonly exception: "Проверка не пройдена";
+    };
+    readonly resource: {
+      readonly invalid: "Неверное значение";
+    };
+    readonly type: {
+      readonly string: "Должно быть текстом";
+      readonly number: "Должно быть числом";
+      readonly boolean: "Должно быть «да» или «нет»";
+      readonly array: "Должно быть списком";
+      readonly object: "Должно быть объектом";
+    };
   };
   readonly actions: {
     readonly close: "Закрыть";
@@ -4505,7 +6004,10 @@ declare const ru: {
   };
   readonly confirm: {
     readonly delete: "Удалить запись?";
-    readonly deleteMany: "Удалить {{count}} записей?";
+    readonly deleteMany_one: "Удалить {{count}} запись?";
+    readonly deleteMany_few: "Удалить {{count}} записи?";
+    readonly deleteMany_many: "Удалить {{count}} записей?";
+    readonly deleteMany_other: "Удалить {{count}} записи?";
     readonly discardChanges: "Отменить изменения?";
     readonly ok: "ОК";
     readonly confirm: "Подтвердить";
@@ -4515,22 +6017,24 @@ declare const ru: {
     readonly proceed: "Всё равно продолжить";
     readonly back: "Вернуться";
     readonly blocked: "Продолжить нельзя";
-    readonly exception: "Проверка не выполнилась";
+    readonly couldNotVerify: "Не удалось проверить «{{checkId}}»";
+    readonly notVerified: "Проверка «{{checkId}}» не выполнилась";
     readonly parseError: "Правило «{{checkId}}» задано неверно: {{detail}}";
   };
   readonly table: {
-    readonly selectedCount: "Выбрано: {{count}}";
+    readonly selectedCount_one: "Выбрано: {{count}}";
+    readonly selectedCount_few: "Выбрано: {{count}}";
+    readonly selectedCount_many: "Выбрано: {{count}}";
+    readonly selectedCount_other: "Выбрано: {{count}}";
     readonly empty: "Нет записей";
     readonly loading: "Загрузка…";
-    readonly rowsSelected: "Выбрано: {{count}}";
+    readonly rowsSelected_one: "Выбрано: {{count}}";
+    readonly rowsSelected_few: "Выбрано: {{count}}";
+    readonly rowsSelected_many: "Выбрано: {{count}}";
+    readonly rowsSelected_other: "Выбрано: {{count}}";
     readonly selectAllRows: "Выбрать все строки";
     readonly selectRow: "Выбрать строку";
   };
-  readonly show: {
-    readonly groups: {
-      readonly other: "Прочее";
-    };
-  };
   readonly boolean: {
     readonly yes: "Да";
     readonly no: "Нет";
@@ -4585,7 +6089,10 @@ declare const ru: {
     readonly clear: "Сбросить";
     readonly reset: "Сбросить";
     readonly title: "Фильтры";
-    readonly selectedCount: "Выбрано: {{count}}";
+    readonly selectedCount_one: "Выбрано: {{count}}";
+    readonly selectedCount_few: "Выбрано: {{count}}";
+    readonly selectedCount_many: "Выбрано: {{count}}";
+    readonly selectedCount_other: "Выбрано: {{count}}";
     readonly is: "равно";
     readonly isNot: "не равно";
     readonly contains: "содержит";
@@ -4605,11 +6112,12 @@ declare const ru: {
   readonly errors: {
     readonly required: "Обязательное поле";
     readonly invalid: "Неверное значение";
-    readonly tooLong: "Не более {{max}} символов";
-    readonly tooShort: "Не менее {{min}} символов";
     readonly failed: "Проверка не пройдена";
     readonly validatorFailed: "Не удалось проверить форму. Попробуйте ещё раз.";
   };
+  readonly access: {
+    readonly restricted: "Нет доступа";
+  };
   readonly list: {
     readonly loadingShort: "Загрузка…";
     readonly notRegistered: "Ресурс не зарегистрирован";
@@ -4619,19 +6127,19 @@ declare const ru: {
     readonly errorDetails: "Подробности";
     readonly emptyTitle: "Пока нет записей";
     readonly emptyBody: "Создайте первую запись, чтобы начать.";
+    readonly emptyBodyReadOnly: "Записи появятся здесь, когда их добавят.";
     readonly emptyFilteredTitle: "Ничего не найдено";
     readonly emptyFilteredBody: "Ни одна запись не соответствует текущему фильтру. Сбросьте фильтр, чтобы увидеть все.";
     readonly clearFilter: "Сбросить фильтр";
     readonly create: "+ Создать {{item}}";
     readonly templateUnknown: "Неизвестный";
     readonly search: "Поиск";
+    readonly predicatesDropped: "Некоторые сохранённые фильтры не применены";
+    readonly flowsMenu: "Ещё действия";
   };
-  readonly tab: {
-    readonly details: "Основное";
-  };
-  readonly tabBody: {
-    readonly empty: "Здесь пока ничего нет.";
-    readonly failed: "Не удалось загрузить вкладку.";
+  readonly timeline: {
+    readonly empty: "Нет записей";
+    readonly undated: "Без даты";
   };
   readonly breadcrumbs: {
     readonly create: "Создание";
@@ -4642,10 +6150,25 @@ declare const ru: {
     readonly resources: "Ресурсы";
     readonly main: "Основная навигация";
     readonly breadcrumb: "Хлебные крошки";
-    readonly language: "Язык";
     readonly toggleSidebar: "Свернуть меню";
     readonly label: "Навигация";
   };
+  readonly shell: {
+    readonly refresh: "Обновить";
+    readonly help: "Справка";
+    readonly scopeSwitcher: "Переключить";
+    readonly scopePlaceholder: "Выберите…";
+    readonly account: "Учётная запись";
+  };
+  readonly theme: {
+    readonly label: "Тема";
+    readonly light: "Светлая";
+    readonly dark: "Тёмная";
+    readonly system: "Системная";
+  };
+  readonly language: {
+    readonly label: "Язык";
+  };
   readonly pageHeader: {
     readonly backTo: "Назад к списку";
     readonly editTitle: "Изменить {{label}}";
@@ -4657,6 +6180,10 @@ declare const ru: {
     readonly emptyBody: "Для этой страницы не зарегистрировано содержимое.";
     readonly notFoundTitle: "Страница не найдена";
     readonly notFoundBody: "Этот адрес не соответствует ни одной зарегистрированной странице.";
+    readonly recordLoading: "Загрузка…";
+    readonly recordNotFound: "Запись не найдена или у вас нет к ней доступа.";
+    readonly recordSessionExpired: "Сеанс истёк. Войдите снова, чтобы продолжить.";
+    readonly recordError: "Не удалось загрузить запись.";
   };
   readonly notifications: {
     readonly region: "Уведомления";
@@ -4666,6 +6193,12 @@ declare const ru: {
     readonly unsupportedType: "Неподдерживаемый тип";
     readonly unsupportedTypeHint: "Тип «{{type}}» не зарегистрирован для этого ресурса.";
     readonly backToPicker: "Назад к выбору типа";
+    readonly typeOffer: {
+      readonly title: "Выберите тип";
+      readonly hint: "От типа зависит, какие поля есть у записи.";
+      readonly empty: "Здесь нельзя создать запись ни одного типа.";
+      readonly change: "Сменить тип";
+    };
   };
   readonly taskRun: {
     readonly idle: "Не запущено";
@@ -4689,7 +6222,10 @@ declare const ru: {
   };
   readonly toolbar: {
     readonly clearAll: "Очистить всё";
-    readonly clearAllAria: "Очистить фильтры: {{count}}";
+    readonly clearAllAria_one: "Очистить фильтры: {{count}}";
+    readonly clearAllAria_few: "Очистить фильтры: {{count}}";
+    readonly clearAllAria_many: "Очистить фильтры: {{count}}";
+    readonly clearAllAria_other: "Очистить фильтры: {{count}}";
     readonly addFilter: "Добавить фильтр";
     readonly filterBy: "Фильтровать по";
     readonly columns: "Колонки";
@@ -4726,6 +6262,7 @@ declare const ru: {
     readonly liveOff: "Авто-обновление: выкл";
   };
   readonly field: {
+    readonly misconfigured: "Это поле настроено неверно";
     readonly removeFile: "Удалить файл";
     readonly pickFile: "Выберите файл или перетащите его сюда";
     readonly dropHint: "Нажмите, чтобы выбрать файл, или перетащите его сюда";
@@ -4737,12 +6274,13 @@ declare const ru: {
   readonly form: {
     readonly systemFields: "Системные поля (только чтение)";
     readonly validating: "Проверка";
-    readonly wizardProgress: "Ход заполнения";
   };
   readonly relation: {
     readonly select: "Выберите…";
     readonly failed: "Не удалось загрузить варианты.";
     readonly noResults: "Ничего не найдено.";
+    /** A lazy `by` relation whose key names no row, found when it is clicked (P3). */
+    readonly unavailable: "Недоступно";
   };
   readonly columnMenu: {
     readonly sortSection: "Сортировка";
@@ -4763,13 +6301,23 @@ declare const ru: {
     readonly body: "На этой странице есть несохранённые изменения. Если уйти сейчас, они будут потеряны.";
     readonly stay: "Остаться";
     readonly leave: "Уйти без сохранения";
+    readonly discard: "Отменить изменения";
+  };
+  readonly navigation: {
+    readonly unsavedAction: "В действии на этом экране есть несохранённые данные";
   };
   readonly relationPicker: {
     readonly viewAll: "Открыть список";
     readonly clear: "Очистить";
     readonly advancedSearch: "Расширенный поиск";
     readonly title: "Выбор: {{name}}";
-    readonly create: "Создать";
+    readonly view: "Открыть";
+    readonly create: "+ Создать";
+    readonly createdNotFitting: "Запись создана, но не подходит для этого поля";
+    readonly createdNotSelected: "Запись создана, но её не удалось выбрать";
+    readonly chooseFirst: "Сначала выберите {{label}}";
+    readonly cannotSearchBy: "Нельзя искать по {{label}}";
+    readonly notMatching: "Не соответствует текущему фильтру";
     readonly select: "Выбрать";
     readonly prev: "Назад";
     readonly next: "Вперёд";
@@ -4780,10 +6328,20 @@ declare const ru: {
     readonly restorePrompt: "Восстановить?";
     readonly restore: "Восстановить";
     readonly discard: "Отклонить";
+    readonly recordChanged: "Запись изменилась после сохранения черновика";
     readonly timeAgoMoment: "только что";
-    readonly timeAgoMinutes: "{{n}} мин назад";
-    readonly timeAgoHours: "{{n}} ч назад";
-    readonly timeAgoDays: "{{n}} дн назад";
+    readonly timeAgoMinutes_one: "{{count}} минуту назад";
+    readonly timeAgoMinutes_few: "{{count}} минуты назад";
+    readonly timeAgoMinutes_many: "{{count}} минут назад";
+    readonly timeAgoMinutes_other: "{{count}} минуты назад";
+    readonly timeAgoHours_one: "{{count}} час назад";
+    readonly timeAgoHours_few: "{{count}} часа назад";
+    readonly timeAgoHours_many: "{{count}} часов назад";
+    readonly timeAgoHours_other: "{{count}} часа назад";
+    readonly timeAgoDays_one: "{{count}} день назад";
+    readonly timeAgoDays_few: "{{count}} дня назад";
+    readonly timeAgoDays_many: "{{count}} дней назад";
+    readonly timeAgoDays_other: "{{count}} дня назад";
     readonly timeAgoRecently: "недавно";
   };
   readonly commandPalette: {
@@ -4867,13 +6425,19 @@ declare const ru: {
       };
     };
     readonly dialog: {
-      readonly titleFilter: "Экспорт {{count}} строк по текущему фильтру";
-      /** `estimatedCount` необязателен в `ExportDialogProps` — показывается, когда для экспорта по фильтру нет известной оценки количества строк. */
+      readonly titleFilter_one: "Экспорт {{count}} строки по текущему фильтру";
+      readonly titleFilter_few: "Экспорт {{count}} строк по текущему фильтру";
+      readonly titleFilter_many: "Экспорт {{count}} строк по текущему фильтру";
+      readonly titleFilter_other: "Экспорт {{count}} строки по текущему фильтру";
+      /** `estimatedCount` is optional on `ExportDialogProps` — shown when a filter-scope export has no known row estimate. */
       readonly titleFilterUnknownCount: "Экспорт строк по текущему фильтру";
-      readonly titleSelected: "Экспорт {{count}} выбранных строк";
-      /** Защитный резерв: Task 8 закрывает триггер по `available` до открытия, так что это достижимо только при прямом/программном монтировании. */
+      readonly titleSelected_one: "Экспорт {{count}} выбранной строки";
+      readonly titleSelected_few: "Экспорт {{count}} выбранных строк";
+      readonly titleSelected_many: "Экспорт {{count}} выбранных строк";
+      readonly titleSelected_other: "Экспорт {{count}} выбранной строки";
+      /** Defensive fallback: Task 8 gates the trigger on `available` before opening, so this is only reachable from a direct/programmatic mount. */
       readonly unavailable: "Экспорт недоступен для этого ресурса.";
-      /** Показывается вместо выбора формата, пока загружается отложенная регистрация экспортёра (`ExporterLoader`). */
+      /** Shown in place of the format selector while a deferred exporter registration (`ExporterLoader`) is still loading. */
       readonly loading: "Подготовка экспорта…";
       readonly format: "Формат";
       readonly columns: "Колонки";
@@ -4892,11 +6456,11 @@ declare const ru: {
       readonly continue: "Продолжить в фоне";
     };
     readonly continuesInBackground: "Экспорт продолжается в фоне.";
-    /** Кнопки экспорта в тулбаре и в панели массовых действий (Task 8) — одно и то же действие, два места вызова. */
+    /** Toolbar/bulk-bar Export entry points (Task 8). Shared by both — the same action, two scopes. */
     readonly button: {
       readonly label: "Экспорт";
     };
-    /** Тосты `useExportRunWatcher()` о завершении экспорта в фоне (Task 8). */
+    /** `useExportRunWatcher()` background-completion toasts (Task 8). */
     readonly toast: {
       readonly succeeded: "Экспорт готов";
       readonly download: "Скачать";
@@ -4906,241 +6470,213 @@ declare const ru: {
   readonly notify: {
     readonly deleted: "Запись удалена";
   };
+  readonly record: {
+    readonly copyId: "Скопировать ID";
+  };
+  /** A quick overlay's header (P3): Back to the previous entry, close, open the record's page. */
+  readonly quick: {
+    readonly back: "Назад к «{{title}}»";
+    readonly close: "Закрыть";
+    readonly openAsPage: "Открыть страницей";
+  };
+  readonly peek: {
+    readonly failed: "Не удалось загрузить";
+    readonly unavailable: "Недоступно";
+  };
+  /** A block placement's framework chrome (P1b+P1c section 8.1). */
+  readonly block: {
+    readonly failed: "Не удалось загрузить раздел.";
+    readonly sessionExpired: "Сессия истекла. Войдите снова, чтобы продолжить.";
+    readonly notImplemented: "Этот раздел недоступен.";
+  };
+  readonly facts: {
+    readonly empty: "Нет данных";
+  };
+  readonly screen: {
+    readonly failed: "Не удалось загрузить раздел.";
+    /** A tab's, step's or collapsed panel's badge: errors, not fields. */
+    readonly errorCount_one: "{{count}} ошибка";
+    readonly errorCount_few: "{{count}} ошибки";
+    readonly errorCount_many: "{{count}} ошибок";
+    readonly errorCount_other: "{{count}} ошибки";
+    readonly expand: "Развернуть";
+    readonly collapse: "Свернуть";
+  };
+  /** A create wizard (a `steps` node in create). */
+  readonly steps: {
+    readonly progress: "Ход заполнения";
+    readonly next: "Далее";
+    readonly back: "Назад";
+    readonly current: "Шаг {{index}} из {{count}}";
+  };
+  /** A flow's host and outcomes (P4 spec 4.22). */
+  readonly flow: {
+    readonly submit: "Отправить";
+    readonly back: "Назад";
+    readonly next: "Далее";
+    readonly checkAgain: "Проверить снова";
+    readonly close: "Закрыть";
+    readonly resend: "Отправить повторно";
+    readonly sendAsNew: "Отправить как новый";
+    readonly sendAsNewConfirm: "Изменение может примениться дважды. Отправить как новый запрос?";
+    readonly startOver: "Я проверил — начать заново";
+    readonly forget: "Я проверил — забыть";
+    readonly couldNotCheck: "Не удалось проверить";
+    readonly couldNotReread: "Не удалось перечитать запись. Ничего не отправлено.";
+    readonly unavailable: "Недоступно.";
+    readonly busyElsewhere: "Это действие выполняется в другой вкладке.";
+    readonly notAvailable: "Это действие недоступно";
+    readonly noLongerApplies: "Это действие больше не применимо";
+    readonly discard: "Отменить";
+    readonly done: "Готово";
+    readonly reset: "Сбросить";
+    readonly rejected: {
+      readonly validation: "Сервер отклонил значения. Ничего не сохранено.";
+      readonly conflict: "Запись изменил кто-то другой. Ничего не сохранено.";
+      readonly forbidden: "У вас нет прав на это действие. Ничего не сохранено.";
+      readonly notFound: "Эта запись больше недоступна.";
+      readonly precondition: "Запись изменилась. Ничего не отправлено.";
+      readonly gone: "Эта запись больше недоступна.";
+    };
+    readonly failed: "Не удалось отправить запрос. Ничего не сохранено.";
+    readonly unknown: "Время ожидания истекло. Изменение могло примениться. Повторно ничего не отправлено.";
+    readonly unknownUnhandled: "Проверьте запись, прежде чем пробовать снова.";
+    readonly resultUnavailable: "Готово; результат здесь недоступен.";
+    readonly bulkSummary_one: "Обработана {{count}} запись";
+    readonly bulkSummary_few: "Обработано {{count}} записи";
+    readonly bulkSummary_many: "Обработано {{count}} записей";
+    readonly bulkSummary_other: "Обработано {{count}} записи";
+    readonly bulkLimit_one: "Выберите не больше {{count}} записи.";
+    readonly bulkLimit_few: "Выберите не больше {{count}} записей.";
+    readonly bulkLimit_many: "Выберите не больше {{count}} записей.";
+    readonly bulkLimit_other: "Выберите не больше {{count}} записей.";
+    readonly bulkUnresolved: "Пропущено: прежний запрос мог уже примениться.";
+    readonly bulkNotAttempted: "Не выполнялось.";
+  };
+  /** A flow's review step (P4 spec 4.4). */
+  readonly review: {
+    readonly changed: "изменено";
+  };
 };
 //#endregion
-//#region src/forms/types.d.ts
-/** The live values map a declarative form reads from and writes to. */
-type FormValues = Record<string, unknown>;
-/**
- * A friendly validator return, resolved through `normalizeFieldIssues` at
- * the boundary. Reused for both per-field validators (`ResourceFieldDefinition.
- * validators`, from `@burojs/core`) and the form-level `validate` below.
- */
-type FormLevelValidationResult = FieldIssue | readonly FieldIssue[] | null | undefined;
+//#region src/forms/controller/screen-state.d.ts
 /**
- * Cross-field / whole-form validator. Receives the full values map plus the
- * same `{ values, field? }` context shape core's per-field `FieldValidator`
- * uses — deliberately NOT the richer visibility/permission `FieldCtx` from
- * the design doc's §4, since predicates and conditional visibility are
- * Task 4. Keeping this context-free is what lets `renderHook` run this
- * controller with no provider wrapper.
+ * Which panels of a screen are open: the `open` input of `planScreen` (P1b+P1c
+ * decision 13), plus `expanded`: the `collapse: 'closed'` panels a user opened.
+ * A host holds no screen, so it cannot list the panels a screen starts
+ * collapsed; the controller adds every `collapse: 'closed'` panel that is not
+ * in `expanded` to `collapsed` before it plans.
  */
-type FormValidate = (values: FormValues, ctx: ValidationContext) => FormLevelValidationResult | Promise<FormLevelValidationResult>;
-/** A validation issue projected for display: one field, one message. */
-interface ResolvedIssue {
-  readonly field: string;
-  readonly severity: ValidationIssueSeverity;
-  readonly message: MessageReference;
+type ScreenOpenState = NonNullable<PlanScreenInput['open']> & {
+  readonly expanded?: readonly string[];
+};
+interface ScreenStateValue {
+  readonly open: ScreenOpenState;
+  openPanel(containerId: string, panelKey: string): void;
+  setCollapsed(containerId: string, collapsed: boolean): void;
+  /** The inline flows this screen instance holds (P6 3.12); released when the screen unmounts. */
+  readonly inline: InlineFlowHolder;
+}
+interface ScreenStateProviderProps {
+  /** The uncontrolled start value. */
+  readonly initialOpen?: ScreenOpenState;
   /**
-   * Interpolation params for a bundle-translated `message.key` (e.g. a
-   * check's `{ checkId, show, trigger }` — `evaluateChecks`, `@burojs/core`).
-   * Forwarded from the source `ValidationIssue.params` so a renderer's
-   * `t(message.key, { params })` call can fill in a `{{placeholder}}` in a
-   * registered bundle entry, mirroring `resource-form.tsx`'s
-   * `resolveIssueMessage` and `<CheckConfirmDialog>`'s own `issueText`.
+   * Controlled: when given, the provider holds no state of its own and plans
+   * this value, so a host can drive it after mount (URL tab state reaching
+   * the plan).
    */
-  readonly params?: Readonly<Record<string, unknown>>;
+  readonly open?: ScreenOpenState;
+  /** Called by `openPanel` and `setCollapsed`, controlled or not. */
+  readonly onOpenChange?: (next: ScreenOpenState) => void;
+  readonly children: ReactNode;
 }
 /**
- * Minimal event shape `handleSubmit`'s returned handler needs. Structurally
- * compatible with a real DOM `FormEvent`, but the controller itself never
- * imports React's DOM event types — it stays usable outside a `<form>`.
+ * Holds what is open on a screen (tabs, steps, collapsed panels) for the form
+ * controller and the renderer below it. Controlled through `open` /
+ * `onOpenChange`, or uncontrolled from `initialOpen`.
+ */
+declare function ScreenStateProvider({ initialOpen, open, onOpenChange, children }: ScreenStateProviderProps): ReactElement;
+/** The screen state, or `null` outside a provider: the controller then plans without `open`. */
+declare function useScreenState(): ScreenStateValue | null;
+//#endregion
+//#region src/forms/controller/use-form-controller.d.ts
+/**
+ * The form controller (P1b+P1c section 10.3): one planned screen, its values
+ * with their seed provenance, validation, checks and the payload allow-list.
+ * A record form passes `resource` and `mode`, and its screen is read from the
+ * compiled snapshot, never from a handle; a resource-less form passes
+ * `fields` (and a `body`), and its screen is compiled by `compileFormScreen`.
  */
-interface SubmitEventLike {
-  readonly preventDefault?: () => void;
+declare function useFormController<F extends ResourceFieldMap>(options: UseFormControllerFormOptions<F>): FormController;
+declare function useFormController(options: UseFormControllerRecordOptions): FormController;
+//#endregion
+//#region src/forms/validation-message.d.ts
+/** What {@link resolveValidationMessage} reads besides the issue. */
+interface ValidationMessageContext {
+  /** A translator that returns the key itself on a miss (`useTranslate`, `useT`). */
+  readonly t: (key: string, options?: {
+    params?: Record<string, unknown>;
+  }) => string;
+  /** `resources.<r>.fields.<f>` (a flow form's: `resources.<r>.actions.<name>.fields.<f>`); absent for a form-level issue. */
+  readonly fieldKey?: string;
 }
 /**
- * The prop bag `<Field {...form.field(name)} />` spreads, and the raw escape
- * hatch for a hand-rolled input. Carries `resource` (derived from
- * `i18nPrefix` via `i18nPrefixToRef`) but deliberately NOT a UI `fallback`
- * node — `@burojs/react` has no shadcn/DOM dependency; the `<Field>` brick
- * in `@burojs/ui-shadcn` supplies its own default fallback.
+ * The one text of a validation issue, resolved at render so a locale switch
+ * reaches it. A lookup hits when `t` returns something other than the key:
+ *
+ * 1. `${fieldKey}.validation.${code}` — the author's per-field override;
+ * 2. `message.key`, when it is not `validation.${code}` (a server or semantic key);
+ * 3. `message.default` — the schema's, validator's or server's own text;
+ * 4. `validation.${code}` — the framework's text for a built-in code;
+ * 5. `errors.failed`.
  *
- * `required`/`disabled`/`hidden` are RESOLVED (Task 4): `hidden` is
- * `!evaluateVisible(field.visible, ctx, values)` (`@burojs/core`'s existing
- * `visible` convention, reused as-is); `required`/`disabled` are each
- * either a static boolean or a predicate `(ctx, values) => boolean`
- * evaluated the same way — see `packages/react/src/forms/conditional.ts`.
+ * Built-in constraint issues carry no `default`, so step 4 answers them in
+ * every locale; an issue with its own `default` keeps it unless step 1 hits.
  */
-interface FieldBinding {
-  readonly name: string;
-  readonly value: unknown;
-  readonly onChange: (value: unknown) => void;
-  readonly onBlur: () => void;
-  readonly error?: ResolvedIssue;
-  readonly warnings: readonly ResolvedIssue[];
-  readonly required: boolean;
-  readonly disabled: boolean;
-  readonly hidden: boolean;
-  readonly resource: EntityRef;
-  readonly field: ResourceFieldDefinition;
-  /**
-   * A relation field's scope, RESOLVED against the current `values` snapshot
-   * (design doc §5). `undefined` when the field declared no `filter` opt (or
-   * a function-form `filter` threw / returned a non-array — same
-   * "broken predicate behaves as if never declared" convention
-   * `resolvePredicate` uses for `required`/`disabled`, see
-   * `./conditional.js`). `@burojs/ui-shadcn`'s `<Field>` merges this into
-   * the field's `meta.filters` — the channel `RelationPickerInput` already
-   * reads (`relation-picker.tsx:478-487,526`) — so a plain `{...binding}`
-   * spread onto `<Field>` (what `<DeclarativeForm>` already does) needs no
-   * extra wiring per field.
-   *
-   * Typed as `FixedFilterInput` (not the bare AST) so it widens together
-   * with `RelationPickerProps.fixedFilters` and
-   * `RelationPickerDialogProps.fixedFilters` downstream — a bare expression
-   * is still a valid `FixedFilterInput`, so `resolveFieldFilter`'s bare-array
-   * return (below) keeps satisfying this without a cast.
-   */
-  readonly fixedFilters?: readonly FixedFilterInput[];
-}
+declare function resolveValidationMessage(issue: Pick<ValidationIssue, 'code' | 'message' | 'params'>, context: ValidationMessageContext): string;
+//#endregion
+//#region src/hooks/use-current-user-id.d.ts
 /**
- * A relation field's `filter` opt (design doc §5) — static, or resolved
- * per-render against the current form values. NOT a typed
- * `@burojs/field-types` builder opt (`RelationFieldOpts` carries no `filter`
- * key — verified empirically the same way the Task 4 report verified
- * `disabled`/`clearWhenHidden`); reachable via the field's raw `.filter` or
- * the builder's `.opts.filter` — see `readFieldFilterOpt` in
- * `./conditional.js`.
- */
-type RelationFilterOpt = readonly FilterExpression<ErasedResourceHandle>[] | ((values: FormValues) => readonly FilterExpression<ErasedResourceHandle>[]);
-interface UseDeclarativeFormOptions {
-  /** The existing field-def map — the same shape `defineResource`'s `f` builder produces. */
-  readonly fields: ResourceFieldMap;
-  /** Controlled values. Presence (not truthiness) of this key selects controlled mode. */
-  readonly value?: FormValues;
-  /** Uncontrolled seed. Ignored once `value` is provided. */
-  readonly defaultValue?: FormValues;
-  readonly onChange?: (values: FormValues) => void;
-  /** Drives label/hint/placeholder i18n, doc address, and the `<Field>` EntityRef. */
-  readonly i18nPrefix?: string;
-  /** Optional whole-form Standard Schema. */
-  readonly schema?: StandardSchemaV1;
-  /** Cross-field validation; may return warnings as well as errors. */
-  readonly validate?: FormValidate;
-  /**
-   * Optional per-field capability seam. Declared for forward compatibility
-   * with the design doc's §4 shape; still unread — an OPEN QUESTION (design
-   * doc §13) whether it should be shaped now to also serve a later
-   * `<ResourceForm>` migration, or stay minimal. NOT how `field(name)
-   * .disabled` is resolved — that is the new `disabled` predicate opt
-   * (Task 4, `./conditional.js`), a separate channel from this capability
-   * seam.
-   */
-  readonly editable?: (field: string, ctx: ValidationContext) => boolean;
-  readonly onSubmit?: (values: FormValues) => unknown | Promise<unknown>;
-  /**
-   * Conditional checks for this form. Declarative forms are resource-less, so
-   * checks are supplied here rather than resolved from a registry. Warnings
-   * never gate `canSubmit`; a `severity: 'error'` check does.
-   */
-  readonly checks?: readonly Check[];
-  /**
-   * Explicit `on: ['create' | 'edit' | ...]` surface for the check pass.
-   * When omitted, `handleSubmit`/`revalidate` INFER it from whether a
-   * baseline was supplied (`value`/`defaultValue` present → `'edit'`, absent
-   * → `'create'`) — but that heuristic misfires for the ordinary "seed a
-   * new record's defaults" create-form shape
-   * (`<DeclarativeForm defaultValue={{ status: 'draft' }} />`), which DOES
-   * supply `defaultValue` yet is still a create. Set this explicitly
-   * whenever the form's create/edit-ness can't be read off "was a baseline
-   * given" — the inference stays the default because the brief mandates it
-   * as the fallback, not because it's always right.
-   */
-  readonly surface?: CheckSurface;
-  /**
-   * Called by `handleSubmit` when a submit-time check pass produced
-   * `confirmable` issues but no `blockers` — ordinary validation AND checks
-   * both passed, and there is something worth a second look before saving.
-   * The host (`<DeclarativeForm>`) supplies this to drive its own confirm
-   * gate (built around `<CheckConfirmDialog>`), seeded with the exact
-   * `CheckOutcome` this controller already computed. There is deliberately
-   * no `useCheckGate(resource)`-style re-derivation here: that hook resolves
-   * its check list from `app.checkSource.checks(resource)`, which has
-   * nothing to key off for a resource-less form whose checks arrive as a
-   * plain option. Resolving `'cancel'` aborts the submit (`onSubmit` is
-   * never called); resolving `'proceed'` — or omitting this option
-   * entirely — behaves exactly like an ordinary non-blocking warning, and
-   * the submit proceeds.
-   */
-  readonly onConfirmChecks?: (outcome: CheckOutcome) => Promise<'proceed' | 'cancel'>;
-}
-interface DeclarativeFormApi {
-  /** Spread into `<Field/>`, or read raw for a hand-rolled input. */
-  field(name: string): FieldBinding;
-  /** Visible fields only, in `options.fields` declaration order — a hidden field is excluded (Task 4). */
-  readonly fields: readonly FieldBinding[];
-  readonly values: FormValues;
-  /** severity 'error' issues, form-level plus per-field, from the last validation pass. */
-  readonly errors: readonly ResolvedIssue[];
-  /** severity 'warning' | 'info' issues — never block `canSubmit`. */
-  readonly warnings: readonly ResolvedIssue[];
-  /** `errors.length === 0 && !isSubmitting`. */
-  readonly canSubmit: boolean;
-  /** Current `values` vs. the baseline captured once at mount. */
-  readonly isDirty: boolean;
-  readonly isSubmitting: boolean;
-  /** The last check pass, for a host that mounts its own confirm gate. */
-  readonly checkOutcome: CheckOutcome | null;
-  handleSubmit(cb?: (values: FormValues) => unknown | Promise<unknown>): (e?: SubmitEventLike) => Promise<void>;
-  setValue(name: string, value: unknown): void;
-  reset(next?: FormValues): void;
-  /**
-   * Re-run every field's + the form's validation against the current
-   * `values` and update `errors`/`warnings`. A live seam for a renderer or
-   * adopter to call on value change (e.g. debounced) — this controller does
-   * NOT call it itself; deciding when to revalidate outside of blur/submit
-   * is the caller's job.
-   */
-  revalidate(): Promise<void>;
-}
+ * The signed-in user's id from the `user` context slot: a non-empty string,
+ * or a finite number as a string; `null` without a slot, while the slot is
+ * pending and for an empty id. The one user-id read of the framework (drafts,
+ * sign-out, recent records).
+ */
+declare function useCurrentUserId(): string | null;
 //#endregion
-//#region src/forms/use-declarative-form.d.ts
+//#region src/hooks/url-state/use-search-params-writer.d.ts
 /**
- * Headless controller for a declarative form: values (controlled or
- * uncontrolled), per-field + cross-field + whole-form-schema validation, the
- * error/warning partition, `canSubmit`, `isDirty`, `handleSubmit` with an
- * anti-double-submit latch, conditional visibility, predicate `required`/
- * `disabled`, and `clearWhenHidden`.
- *
- * Reads `useOptionalVisibilityCtx()` (`../hooks/use-permissions.js`) as the
- * `ctx` argument every `visible`/`required`/`disabled` predicate receives —
- * NOT `useVisibilityCtx`, which throws outside a `BuroProvider`. This
- * controller must stay instantiable via a bare
- * `renderHook(() => useDeclarativeForm(...))`, no wrapper (Task 3's own
- * suite does this, and a form with no conditional fields has no reason to
- * require the whole app's provider tree just to mount) — the optional
- * variant defaults `ctx` to `{}` outside a provider instead.
+ * Writes in-page URL state (a record tab, list state): `update` edits a copy
+ * of the current search params, and the result is written on the same
+ * pathname, by default with `replace`. Never asks the navigation guard and
+ * never changes the pathname; a navigation to another page goes through
+ * `useRouteNavigate`. Without a router adapter it does nothing.
  */
-declare function useDeclarativeForm(options: UseDeclarativeFormOptions): DeclarativeFormApi;
+declare function useSearchParamsWriter(): (update: (params: URLSearchParams) => void, options?: {
+  readonly history?: 'push' | 'replace';
+}) => void;
 //#endregion
-//#region src/forms/conditional.d.ts
-/** A field's resolved (predicate-evaluated) visibility/required/disabled state for one values snapshot. */
-interface ResolvedFieldFlags {
-  /** `!visible` — the `fields` getter and validation both key off this. */
-  readonly hidden: boolean;
-  readonly required: boolean;
-  readonly disabled: boolean;
+//#region src/record/record-frame-context.d.ts
+/** What a record frame gives the pieces rendered inside `<RecordScreen>`. */
+interface RecordFrameValue {
+  /** The resource's canonical name. */
+  readonly resource: string;
+  readonly recordId: string | undefined;
+  readonly mode: ScreenMode;
+  /** The record being shown or edited, once it is read; `undefined` in create. */
+  readonly record: Readonly<Record<string, unknown>> | undefined;
+  /** The form controller planning the frame's screen. */
+  readonly controller: FormController;
 }
+/** The record frame `<RecordScreen>` provides; `null` outside one. */
+declare const RecordFrameContext: import("react").Context<RecordFrameValue | null>;
 /**
- * Resolve one field's `hidden`/`required`/`disabled` against a ctx + values
- * snapshot.
- *
- * `hidden` is `!evaluateVisible(...)` — core's real evaluator
- * (`@burojs/core`'s `permissions.ts:121-136`), reused as-is rather than
- * reimplemented: undefined → visible (adopters opt INTO gating); a throw →
- * NOT visible, unconditionally (fail-closed). This is THE existing `visible`
- * convention every other renderer (`<ResourceList>`, `<ResourceShow>`,
- * `<ResourceForm>`) already consults — reusing it, rather than routing
- * `visible` through the more generic `resolvePredicate` below, is what
- * keeps this controller's conditional-visibility semantics identical to
- * theirs.
- *
- * `required`/`disabled` default to `false` when undeclared or on a throw
- * (`resolvePredicate`) — "no predicate declared → behave exactly as before
- * this feature existed".
+ * The record frame around the caller. A frame piece rendered outside
+ * `<RecordScreen>` is a development error (P1b+P1c decision 6), so this throws there.
  */
-declare function resolveFieldFlags(fieldDef: unknown, ctx: unknown, values: FormValues): ResolvedFieldFlags;
+declare function useRecordFrame(): RecordFrameValue;
+/** The record frame around the caller, or `null` outside `<RecordScreen>`. */
+declare function useOptionalRecordFrame(): RecordFrameValue | null;
 //#endregion
 //#region src/export/runs-store.d.ts
 interface ExportRunEntry {
@@ -5286,5 +6822,5 @@ declare function useResourceExport(resource: string, opts?: UseResourceExportOpt
 declare const PACKAGE_NAME: "@burojs/react";
 declare const PACKAGE_VERSION: "0.0.0";
 //#endregion
-export { type AppActionEntry, type ApplyViewToUrlStateOptions, type ApplyViewUrlStateSetters, type AuthController, type BuildFormDiffArgs, type BuroDehydratedData, BuroPresentationOutlet, BuroProvider, type BuroProviderProps, BuroRoutes, BuroRuntimeProvider, type BuroRuntimeProviderProps, type CapabilityResolver, type CheckGateRequest, type CheckGateState, type CodecOptions, type CollectionDisplayProps, type CollectionInputProps, ComponentsContext, type CountExecution, type CreateAuthControllerOptions, type CreateDataRuntimeOptions, type CreateDataRuntimeTransitionParticipantOptions, type CustomPageRouteDescriptor, DEFAULT_HISTORY_MODE, type DataRuntimeContextValue, type DataRuntimeLease, type DataRuntimeTransitionParticipant, type DataSessionController, type DataSessionState, type DataSessionTransitionParticipant, type DeclarativeFormApi, type DefinedField, type DocPanelApi, type DocPanelTarget, type DocScopeView, type DocTopicView, DocsProvider, type DocumentedScope, EMPTY_FIELD_IMPLEMENTATIONS, type ExportRunEntry, ExportRunsStore, type FieldAccessibilityIds, type FieldBinding, type FieldI18n, type FieldImplementation, type FieldImplementationCatalog, type FieldImplementationComponent, type FieldImplementationDiagnostic, type FieldImplementationLayout, type FieldImplementationMap, FieldImplementationProvider, type FieldImplementationSource, type FieldPresentation, type FieldRenderContext, type FieldRenderSurface, type FieldTestIds, type FieldType, type FieldUiHints, type FileItem, type FileItemStatus, type FilterFieldSpec, type FilterFieldsResult, type FilterKind, type FormSubmitAudit, type FormSubmitAuditArgs, type FormValues, type HistoryMode, I18nContext, type InfiniteListData, type InitialManifest, LOCAL_USER_SCOPE_ID, type LocalStorageUiSettingsAdapterOptions, type ManifestHydration, type ManifestHydrationScope, type NativeInfiniteListResult, type NativeMutationOptions, type NativeQueryOptions, type NativeQueryResult, PACKAGE_NAME, PACKAGE_VERSION, type PresentationsMode, RENDER_TIME_DATA, RESOLVE_COOLDOWN_MS, RESOURCE_URL_STATE_LIMITS, type RecentEnvelope, type RecentRecord, RecordCodecError, type RecordCodecOutcome, type RelatedRecord, RelationAggregatorProvider, type RelationAggregatorProviderProps, type RelationFilterOpt, type ResolvedFieldFlags, type ResolvedFieldImplementation, type ResolvedIssue, type ResolvedItemAction, ResourceContext, type ResourceListController, ResourceListProvider, type ResourceListProviderProps, type ResourceRecordCodec, type ResourceRouteDescriptor, type ResourceUrlState, type RouteDescriptor, type RouterAdapter, RouterAdapterProvider, type RouterAdapterProviderProps, type RowRecord, type SavedViewEntry, type ScalarDisplayProps, type ScalarInputProps, type SetterOptions, type TaskRunController, type TaskRunReporter, type TestIdBuilder, TestIdContext, UIActivationSurfaceProvider, type UIInstance, UIInstanceProvider, type UIPresent, type UIPresentInput, type UIPresentationHost, type UIPresentationHostProps, type UIPresentationHosts, type UIPresentationLifecycle, type UIPresentationOptionsSchema, UIPresentationRuntimeProvider, UIPresentations, type UIPresentationsProps, UiSettingsProvider, type UiSettingsProviderProps, type UrlCache, type UseActionArgs, type UseActionResult, type UseBulkActionArgs, type UseBulkActionResult, type UseCapabilityArgs, type UseCheckGateResult, type UseChecksOptions, type UseChecksResult, type UseCommandPaletteOptions, type UseCommandPaletteResult, type UseCountOptions, type UseCreateManyOptions, type UseCreateOneOptions, type UseCustomMutationOptions, type UseCustomQueryOptions, type UseDeclarativeFormOptions, type UseDeleteManyOptions, type UseDeleteOneOptions, type UseEnumValuesResult, type UseFieldImplementationArgs, type UseFileFieldArgs, type UseFileFieldResult, type UseFileUrlsOpts, type UseFileUrlsResult, type UseFilterFieldsOptions, type UseInfiniteListOptions, type UseListOptions, type UseManyOptions, type UseOneOptions, type UseRelatedRecordResult, type UseResourceExportOptions, type UseResourceExportResult, type UseResourceListOptions, type UseSavedViewsResult, type UseTaskRunOptions, type UseTrackRecentRecordOptions, type UseUiSettingsCollectionResult, type UseUiSettingsResult, type UseUiSettingsSingletonResult, type UseUpdateManyOptions, type UseUpdateOneOptions, applyViewToUrlState, buildDI, buildFormDiff, buroMutationOptions, clearRecentRecords, composeFieldImplementations, createAuthController, createDataRuntime, createDataRuntimeTransitionParticipant, createDataSession, createLocalStorageUiSettingsAdapter, createManifestHydrationScope, createResourceRecordCodec, createRuntimeActionDataAccess, createUrlCache, defineFieldWithImplementation, dehydrateBuroData, deserializeResourceState, disposeBuroRequest, en, formatBytes, generateRouteDescriptors, getRecentRecords, getResourceParams, hydrateBuroData, hydrateManifest, isCustomPageRoute, matchesAccept, mergeComponents, modeForSurface, normalizeServerRecordIssues, resolveCountExecution, resolveFieldFlags, resolveFieldImplementation, ru, serializeBuroHydration, serializeResourceState, sharedUrlCache, useAction, useApp, useAppActions, useApplicationSnapshot, useAudit, useAvailability, useAvailabilityGate, useAvailabilityResolver, useBulkAction, useCapability, useCapabilityResolver, useChangeLocale, useCheckGate, useChecks, useCommandPalette, useComponent, useCount, useCreateMany, useCreateOne, useCtx, useCurrentResource, useCurrentUIActivation, useCustomMutation, useCustomQuery, useDataRuntime, useDebouncedValue, useDeclarativeForm, useDefaultComponent, useDeleteMany, useDeleteOne, useDismissExportRun, useDoc, useDocPanel, useDocScopes, useDocTopic, useDocTopics, useDocTrailScopes, useDocsConfig, useDocumentedScopes, useEnumValues, useExportRuns, useFieldImplementation, useFieldImplementationCatalog, useFileField, useFileStorage, useFileUrls, useFilterFields, useFormSubmitAudit, useHasDocTopics, useI18nCaps, useIdentity, useInfiniteList, useIsAuthenticated, useItemActions, useLayerRuntime, useLayerStatus, useList, useLocalStorage, useLocale, useLogin, useLogout, useMany, useOne, useOptionalDataRuntime, useOptionalFileStorage, useOptionalLocale, useOptionalT, useOptionalUIActivationSurface, useOptionalUIInstance, useOptionalUIPresentation, useOptionalVisibilityCtx, usePermissions, useProjection, usePublishDocVariant, useRecordTitle, useRelatedRecord, useResource, useResourceExport, useResourceI18n, useResourceList, useResourceListContext, useResourceUrlState, useRouterAdapter, useSavedViews, useScopeCtx, useSetSlice, useT, useTaskRun, useTestIds, useTrackRecentRecord, useTrailHasDocs, useTranslate, useUIInstance, useUIPresent, useUIPresentationRuntime, useUiSettings, useUpdateMany, useUpdateOne, useVisibilityCtx, useVisibleTemplates, validateBuroHydration };
+export { type AppActionEntry, type AppAudit, type ApplyViewToUrlStateOptions, type ApplyViewUrlStateSetters, type AuthController, BLOCK_COMPONENT, type BlockDataEntryName, type BlockImplementation, type BlockImplementationCatalog, type BlockScreenProps, type BlockViewPropValues, type BlockViewProps, type BuroDehydratedData, BuroPresentationOutlet, BuroProvider, type BuroProviderProps, BuroRoutes, BuroRuntimeProvider, type BuroRuntimeProviderProps, type CandidatesAccess, type CapabilityResolver, type CheckGateRequest, type CheckGateState, type CodecOptions, type CollectionDisplayProps, type CollectionInputProps, ComponentsContext, type CountExecution, type CreateAuthControllerOptions, type CreateDataRuntimeOptions, type CreateDataRuntimeTransitionParticipantOptions, type CustomPageRouteDescriptor, DEFAULT_HISTORY_MODE, DEFAULT_LANGUAGE_STORAGE_KEY, type DataRuntimeContextValue, type DataRuntimeLease, type DataRuntimeTransitionParticipant, type DataSessionController, type DataSessionState, type DataSessionTransitionParticipant, type DefinedField, type DismissGuard, DismissGuardScope, type DismissScopeValue, DispatcherProvider, type DispatcherProviderProps, type DocPanelApi, type DocPanelTarget, type DocScopeView, type DocTopicView, DocsProvider, type DocumentedScope, EMPTY_FIELD_IMPLEMENTATIONS, type EntryAnswer, type EntryKind, type ExportRunEntry, ExportRunsStore, FLOW_COMPONENT, type FieldAccessibilityIds, type FieldBinding, type FieldI18n, type FieldImplementation, type FieldImplementationCatalog, type FieldImplementationComponent, type FieldImplementationDiagnostic, type FieldImplementationLayout, type FieldImplementationMap, FieldImplementationProvider, type FieldImplementationSource, type FieldMetaState, type FieldPresentation, type FieldRenderContext, type FieldRenderSurface, type FieldTestIds, type FieldType, type FieldUiHints, type FileItem, type FileItemStatus, type FilterFieldSpec, type FilterFieldsResult, type FilterKind, FlowRowBatchContext, type FlowRowBatchValue, type FlowRowControl, type FlowRowState, type FlowScreenProps, type FlowStart, type FormController, type FormControllerFailure, type FormDraftState, type FormSteps, type FormSubmitResult, type FormValues, FrameCheckContext, type FrameCheckValue, type FrameImplementation, type FrameImplementationCatalog, type FrameNodeAttributes, type FramePiece, type FrameStep, type FrameTab, type FrameTranslate, type FrameViewProps, type HistoryMode, type HostPage, I18nContext, type InfiniteListData, type InitialManifest, type InlineFlowHolder, type InlineLease, LOCAL_USER_SCOPE_ID, type ListFrameViewProps, type ListState, type LocalStorageUiSettingsAdapterOptions, type ManifestHydration, type ManifestHydrationScope, type NativeInfiniteListResult, type NativeMutationOptions, type NativeQueryOptions, type NativeQueryResult, type NavigationBlockerHandle, type NavigationGuardPrompt, type NavigationGuardText, type NotificationSink, type NotificationSinkMessage, PACKAGE_NAME, PACKAGE_VERSION, PEEK_COMPONENT, type PageAccess, type PageFlowGate, type PageFrameViewProps, type PageScreen, type PanelFrameViewProps, type PeekFrameViewProps, type PeekScreenProps, type PlacementRuntime, type PlacementView, type PresentBlockInput, type PresentFlowInput, type PresentationsMode, type ProjectedRecord, QUICK_ANCHOR_ATTRIBUTE, QUICK_COMPONENT, type QuickApi, type QuickEntry, QuickEntryContext, type QuickEntryValue, type QuickOpen, type QuickScreenProps, type QuickSettledRow, type QuickStack, RELATION_BATCH_MAX_PAGE, RENDER_TIME_DATA, RESERVED_LIST_SUFFIXES, RESOLVE_COOLDOWN_MS, RESOURCE_URL_STATE_LIMITS, RecordCodecError, type RecordCodecOutcome, RecordFrameContext, type RecordFrameSlots, type RecordFrameValue, type RecordFrameViewProps, type RelatedRecord, type RelationFilterOpt, type ResolvedFieldImplementation, type ResolvedIssue, type ResolvedItemAction, ResourceContext, type ResourceFlowSurface, type ResourceListController, ResourceListProvider, type ResourceListProviderProps, type ResourceRecordCodec, type ResourceRouteDescriptor, type ResourceUrlState, type RouteDescriptor, type RouteNavigate, type RouteNavigateOptions, RouteSourceContext, type RouterAdapter, RouterAdapterProvider, type RouterAdapterProviderProps, type RowRecord, type SavedViewEntry, type ScalarDisplayProps, type ScalarInputProps, type ScreenOpenState, ScreenStateProvider, type ScreenStateProviderProps, type ScreenStateValue, type SetterOptions, type StepsFrameViewProps, type TabsFrameViewProps, type TaskRunController, type TaskRunReporter, type TestIdBuilder, TestIdContext, UIActivationSurfaceProvider, type UIInstance, UIInstanceProvider, type UIPresent, type UIPresentInput, type UIPresentationHost, type UIPresentationHostProps, type UIPresentationHosts, type UIPresentationLifecycle, type UIPresentationOptionsSchema, UIPresentationRuntimeProvider, type UIPresentationScreens, UIPresentations, type UIPresentationsProps, UiSettingsProvider, type UiSettingsProviderProps, type UrlCache, type UseCapabilityArgs, type UseCheckGateResult, type UseChecksOptions, type UseChecksResult, type UseCommandPaletteOptions, type UseCommandPaletteResult, type UseCountOptions, type UseCreateOneOptions, type UseCustomMutationOptions, type UseCustomQueryOptions, type UseDeleteManyOptions, type UseDeleteOneOptions, type UseEnumValuesResult, type UseFieldImplementationArgs, type UseFileFieldArgs, type UseFileFieldResult, type UseFileUrlsOpts, type UseFileUrlsResult, type UseFilterFieldsOptions, type UseFormControllerFormOptions, type UseFormControllerRecordOptions, type UseInfiniteListOptions, type UseListOptions, type UseManyOptions, type UseOneOptions, type UseRefreshResult, type UseRelatedRecordOptions, type UseRelatedRecordResult, type UseResourceExportOptions, type UseResourceExportResult, type UseResourceListOptions, type UseSavedViewsResult, type UseTaskRunOptions, type UseUiSettingsCollectionResult, type UseUiSettingsResult, type UseUiSettingsSingletonResult, type UseUpdateManyOptions, type UseUpdateOneOptions, type ValidationMessageContext, applyViewToUrlState, buildDI, buroMutationOptions, composeBlockImplementations, composeFieldImplementations, composeFrameImplementations, conjoinHostPage, createAuthController, createDataRuntime, createDataRuntimeTransitionParticipant, createDataSession, createLocalStorageUiSettingsAdapter, createManifestHydrationScope, createResourceRecordCodec, createRuntimeActionDataAccess, createUrlCache, defineFieldWithImplementation, dehydrateBuroData, deserializeResourceState, disposeBuroRequest, en, fieldImplementation, filterFields, formatBytes, generateRouteDescriptors, getResourceParams, hostPageFor, hostPageRef, hydrateBuroData, hydrateManifest, implementBlock, implementFrame, isCustomPageRoute, matchesAccept, mergeComponents, modeForSurface, normalizeServerRecordIssues, pageAccessFor, policyRecordOf, policyRowsOf, quickAnchorRef, resolveCountExecution, resolveFieldImplementation, resolveRoute, resolveValidationMessage, resourceFlowsOn, retryRecordRead, ru, serializeBuroHydration, serializeResourceState, sharedUrlCache, useApp, useAppActions, useApplicationSnapshot, useAudit, useAvailability, useAvailabilityGate, useAvailabilityResolver, useCandidatesAccess, useCapability, useCapabilityResolver, useChangeLocale, useCheckGate, useChecks, useCommandPalette, useComponent, useCount, useCreateOne, useCtx, useCurrentResource, useCurrentUIActivation, useCurrentUserId, useCustomMutation, useCustomQuery, useDataRuntime, useDebouncedValue, useDefaultComponent, useDeleteMany, useDeleteOne, useDismissExportRun, useDismissGuard, useDismissPending, useDispatcher, useDispatcherEffects, useDoc, useDocPanel, useDocScopes, useDocTopic, useDocTopics, useDocTrailScopes, useDocsConfig, useDocumentedScopes, useEntryGate, useEnumValues, useExportRuns, useFieldAccess, useFieldImplementation, useFieldImplementationCatalog, useFieldMeta, useFieldMetaSources, useFileField, useFileStorage, useFileUrls, useFilterFields, useFlowFormCatalog, useFlowOpenImplementation, useFlowRowBatch, useFlowRowResolver, useFormController, useFrameImplementations, useFramePiece, useFrameT, useHasDocTopics, useHostPage, useI18nCaps, useIdentity, useInfiniteList, useIsAuthenticated, useItemActions, useLanguageStorageKey, useLayerRuntime, useLayerStatus, useList, useListAccess, useLocalStorage, useLocale, useLogin, useLogout, useMany, useNavigationBlocker, useNavigationGuardText, useNavigationHold, useOne, useOptionalAuthController, useOptionalDataRuntime, useOptionalFileStorage, useOptionalLocale, useOptionalRecordFrame, useOptionalRouterAdapter, useOptionalT, useOptionalUIActivationSurface, useOptionalUIInstance, useOptionalUIPresentation, useOptionalVisibilityCtx, usePageAccess, usePageFlowGate, usePageScreen, usePermissions, usePlacement, usePresentBlock, usePresentFlow, useProjectedRecord, useProjectedTitle, useProjection, usePublishDocVariant, useQuick, useQuickEntry, useQuickEntryValue, useQuickOpener, useRecordFrame, useRecordTitle, useRefresh, useRegisterNavigationGuardDialog, useRegisterNotificationSink, useRelatedRecord, useResource, useResourceExport, useResourceI18n, useResourceList, useResourceListContext, useResourceUrlState, useRouteListImplementation, useRouteNavigate, useRouterAdapter, useSavedViews, useScopeCtx, useScreenState, useSearchParamsWriter, useSetSlice, useT, useTaskRun, useTestIds, useTrailHasDocs, useTranslate, useUIInstance, useUIPresent, useUIPresentationRuntime, useUiSettings, useUpdateMany, useUpdateOne, useViewRow, useVisibilityCtx, validateBuroHydration };
 //# sourceMappingURL=index.d.ts.map