alinea 2.0.0-preview.13 → 2.0.0-preview.14

package/dist/bundled.d.ts

@@ -432,6 +432,19 @@ declare module 'alinea/backend/api/GithubApi' {
   import type { CommitRequest } from 'alinea/core/db/CommitRequest';
   import { GithubSource, type GithubSourceOptions } from 'alinea/core/source/GithubSource';
   export interface GithubOptions extends GithubSourceOptions {
+      /**
+       * Commit as this author instead of the account that owns the token. Such
+       * commits are written through the REST API, which GraphQL commits do not
+       * allow, so GitHub does not mark them as verified. A save usually spends
+       * three REST requests, plus one per uploaded file. Removing a file that is
+       * already gone costs one more tree request, and a branch that moved in
+       * the meantime repeats the save.
+       */
+      author?: GithubCommitAuthor;
+  }
+  export interface GithubCommitAuthor {
+      name: string;
+      email: string;
   }
   export class GithubApi extends GithubSource implements HistoryApi, CommitApi, SyncApi {
       #private;
@@ -627,6 +640,28 @@ declare module 'alinea/backend/Auth' {
   
 }
 
+declare module 'alinea/backend/CommitEntries' {
+
+  import type { DashboardEntry } from 'alinea/core/DashboardEntry';
+  import type { Mutation } from 'alinea/core/db/Mutation';
+  import type { Resolver } from 'alinea/core/Resolver';
+  /** An entry that no longer exists after a commit */
+  export interface RemovedEntry {
+      id: string;
+      type: string;
+      locale: string | null;
+      /** The url the entry had before the commit */
+      url: string;
+  }
+  /**
+   * The latest version, in every locale, of the entries that mutations change
+   */
+  export function committedEntries(resolver: Resolver, mutations: ReadonlyArray<Mutation>): Promise<Array<DashboardEntry>>;
+  /** The entries of `before` that are not in `after` */
+  export function removedEntries(before: Array<DashboardEntry>, after: Array<DashboardEntry>): Array<RemovedEntry>;
+  
+}
+
 declare module 'alinea/backend/HandleAction' {
 
   export enum HandleAction {
@@ -653,6 +688,8 @@ declare module 'alinea/backend/Handler' {
   import type { CMS } from 'alinea/core/CMS';
   import type { AuthedContext, RemoteConnection, RequestContext } from 'alinea/core/Connection';
   import type { LocalStore } from 'alinea/core/db/LocalStore';
+  import type { DashboardEntry } from 'alinea/core/DashboardEntry';
+  import { type RemovedEntry } from 'alinea/backend/CommitEntries';
   import type { Mutation } from 'alinea/core/db/Mutation';
   import type { User } from 'alinea/core/User';
   export interface Handler {
@@ -666,6 +703,13 @@ declare module 'alinea/backend/Handler' {
   }
   export interface AfterCommitContext extends BeforeCommitContext {
       sha: string;
+      /**
+       * The entries the mutations changed as they are after the commit: the
+       * latest version in each locale
+       */
+      entries: Array<DashboardEntry>;
+      /** Entries that no longer exist after the commit, with the url they had */
+      removed: Array<RemovedEntry>;
   }
   export interface HandlerHooks {
       beforeCommit?(context: BeforeCommitContext): HookResponse<ReadonlyArray<Mutation>>;
@@ -969,6 +1013,12 @@ declare module 'alinea/backend/util/ORM' {
 
 declare module 'alinea/backend/util/Syncable' {
 
+  /**
+   * How long a read waits for a sync with the remote. A slower or hung remote
+   * must not hold up every read: past this the read answers with the content
+   * it has, while the sync carries on.
+   */
+  export const syncWait = 10000;
   export function createThrottledSync(): (sync: () => Promise<unknown>, interval?: number) => Promise<void>;
   
 }
@@ -996,7 +1046,11 @@ declare module 'alinea/cli/build/BuildEmitter' {
       type: 'done';
       result: BuildResult;
   };
-  export function buildEmitter(config: BuildOptions): Emitter<BuildInfo>;
+  export interface BuildEmitterOptions {
+      /** Rebuild on changes, otherwise build once and stop esbuild */
+      watch?: boolean;
+  }
+  export function buildEmitter(config: BuildOptions, { watch }?: BuildEmitterOptions): Emitter<BuildInfo>;
   
 }
 
@@ -1083,7 +1137,10 @@ declare module 'alinea/cli/generate/DevDB' {
        */
       reconfigure(options: Pick<DevDBOptions, 'config' | 'configFingerprint' | 'dashboardUrl'>): Promise<void>;
       sync(): Promise<string>;
-      finalize(): Promise<number>;
+      /** Compact the database, rewriting it in full for a build. */
+      finalize(options?: {
+          rewrite?: boolean;
+      }): Promise<number>;
       fix(): Promise<void>;
       watchFiles(): Promise<WatchFiles>;
       isInMediaLocation(file: string): boolean;
@@ -1175,6 +1232,29 @@ declare module 'alinea/cli/generate/LoadConfig' {
   
 }
 
+declare module 'alinea/cli/generate/MediaLocations' {
+
+  import { type EntryStatus } from 'alinea/core/Entry';
+  import type { EntryStore } from 'alinea/database/EntryStore';
+  export interface RemoteLocation {
+      id: string;
+      locale: string | null;
+      status: EntryStatus;
+      workspace: string;
+      /** The content file of the media entry */
+      file: string;
+      location: string;
+      /** The location of the one file with the same name in the mediaDir */
+      local?: string;
+  }
+  /**
+   * Media entries whose location is a url. Only the 1.x dashboard wrote those
+   * (upload urls belong in previewUrl), they can't be served from the site.
+   */
+  export function remoteLocations(rootDir: string, db: EntryStore): Promise<Array<RemoteLocation>>;
+  
+}
+
 declare module 'alinea/cli/Init' {
 
   export interface InitOptions {
@@ -1916,14 +1996,16 @@ declare module 'alinea/cms' {
    * @module
    */
   export { useField, useFieldError, useFieldKey, useFieldOptions, useFieldSetter, useFieldValue, useSiblingFieldValue } from 'alinea/dashboard/cms/hooks';
-  export { type DashboardLocation, useEntry, useGraph, useLocale, useNavigate, usePolicy, usePreviewMetadata, useUser } from 'alinea/dashboard/cms/hooks';
+  export { useEntry, useGraph, useLocale, useNavigate, usePolicy, usePreviewMetadata, useUser } from 'alinea/dashboard/cms/hooks';
+  export type { DashboardEntry, EntryActionProps } from 'alinea/core/DashboardEntry';
+  export type { DashboardLocation } from 'alinea/dashboard/Href';
   export type { Policy } from 'alinea/core/Role';
   export type { PreviewMetadata } from 'alinea/core/Preview';
   export type { User } from 'alinea/core/User';
   export { EditField, type EditFieldProps, EditFields, type EditFieldsProps } from 'alinea/dashboard/app/EntryFields';
   export { FieldChrome, type FieldChromeProps } from 'alinea/dashboard/cms/FieldChrome';
   export { EntryTable, type EntryTableProps } from 'alinea/dashboard/cms/EntryTable';
-  export type { OverviewActionProps, OverviewCellProps, OverviewEntry } from 'alinea/core/Overview';
+  export type { OverviewActionProps, OverviewCellProps, OverviewEntry, OverviewHeaderProps } from 'alinea/core/Overview';
   export type { FieldViewProps, RootViewProps, SectionViewProps, TypeViewProps } from 'alinea/dashboard/cms/ViewProps';
   
 }
@@ -1932,6 +2014,7 @@ declare module 'alinea/components' {
 
   export * from 'alinea/components/Alert';
   export * from 'alinea/components/AppShell';
+  export * from 'alinea/components/AsyncList';
   export * from 'alinea/components/Badge';
   export * from 'alinea/components/Blockquote';
   export * from 'alinea/components/Breadcrumbs';
@@ -1958,6 +2041,7 @@ declare module 'alinea/components' {
   export * from 'alinea/components/Field';
   export * from 'alinea/components/FileTrigger';
   export * from 'alinea/components/FoldIcon';
+  export * from 'alinea/components/Form';
   export * from 'alinea/components/Heading';
   export * from 'alinea/components/Icon';
   export * from 'alinea/components/Kbd';
@@ -1978,6 +2062,7 @@ declare module 'alinea/components' {
   export * from 'alinea/components/Sidebar';
   export * from 'alinea/components/SortableList';
   export * from 'alinea/components/Spinner';
+  export * from 'alinea/components/Stack';
   export * from 'alinea/components/Surface';
   export * from 'alinea/components/Switch';
   export * from 'alinea/components/Table';
@@ -2050,6 +2135,63 @@ declare module 'alinea/components/AppShell' {
   
 }
 
+declare module 'alinea/components/AsyncList' {
+
+  import type { Key, Selection, SortDescriptor } from 'alinea/components/types';
+  export interface AsyncListLoadOptions<C> {
+      /** Aborted when a newer load replaces this one */
+      signal: AbortSignal;
+      /** The cursor returned by the previous page, set when loading more */
+      cursor?: C;
+      filterText: string;
+      sort?: SortDescriptor;
+  }
+  export interface AsyncListPage<T, C> {
+      items: Iterable<T>;
+      /** Where the next page starts, leave out when there are no more items */
+      cursor?: C | null;
+  }
+  export interface AsyncListOptions<T, C> {
+      load(options: AsyncListLoadOptions<C>): Promise<AsyncListPage<T, C>>;
+      initialSort?: SortDescriptor;
+      initialFilterText?: string;
+      initialSelectedKeys?: Iterable<Key>;
+      /** The key of an item, defaults to its `id` or `key` property */
+      getKey?: (item: T) => Key;
+  }
+  /**
+   * Items loaded page by page. Its fields plug into Table (`items`,
+   * `sortDescriptor`/`onSortChange`, `loading`, `onLoadMore`, `selectedKeys`/
+   * `onSelectionChange`) and ComboBox (`inputValue`/`onInputValueChange`,
+   * `loading`).
+   */
+  export interface AsyncList<T> {
+      items: Array<T>;
+      /** True while loading the first page, the next page, sorting or filtering */
+      loading: boolean;
+      /** The error the last load failed with */
+      error?: Error;
+      /** Whether the last page returned a cursor */
+      hasMore: boolean;
+      loadMore(): void;
+      reload(): void;
+      /** Replaces an item, eg. after saving it, without loading the list again */
+      update(key: Key, item: T | ((previous: T) => T)): void;
+      remove(...keys: Array<Key>): void;
+      prepend(...items: Array<T>): void;
+      append(...items: Array<T>): void;
+      sortDescriptor?: SortDescriptor;
+      sort(descriptor: SortDescriptor): void;
+      filterText: string;
+      setFilterText(text: string): void;
+      selectedKeys: Selection;
+      setSelectedKeys(keys: Selection): void;
+  }
+  /** Loads a list of items, with sorting, filtering and paging */
+  export function useAsyncList<T, C = string>({ load, initialSort, initialFilterText, initialSelectedKeys, getKey }: AsyncListOptions<T, C>): AsyncList<T>;
+  
+}
+
 declare module 'alinea/components/Badge' {
 
   import type { ReactElement, ReactNode } from 'react';
@@ -2323,13 +2465,14 @@ declare module 'alinea/components/ColorSwatchPicker' {
 
 declare module 'alinea/components/ComboBox' {
 
-  import { type ReactNode } from 'react';
-  import type { AriaProps, DataProps, FieldSharedProps, OpenStateProps, StyleProps } from 'alinea/components/types';
-  export interface ComboBoxProps extends FieldSharedProps, OpenStateProps, StyleProps, AriaProps, DataProps {
-      value?: string | null;
-      defaultValue?: string | null;
+  import { type ReactElement, type ReactNode } from 'react';
+  import type { AriaProps, DataProps, FieldSharedProps, IconType, Key, OpenStateProps, StyleProps } from 'alinea/components/types';
+  export interface ComboBoxProps<V extends Key = Key> extends FieldSharedProps, OpenStateProps, StyleProps, AriaProps, DataProps {
+      /** The value of the selected ComboBoxItem */
+      value?: V | null;
+      defaultValue?: V | null;
       /** Called with the selected value, or null when the selection is cleared */
-      onValueChange?: (value: string | null) => void;
+      onValueChange?: (value: V | null) => void;
       inputValue?: string;
       defaultInputValue?: string;
       onInputValueChange?: (value: string) => void;
@@ -2338,22 +2481,39 @@ declare module 'alinea/components/ComboBox' {
       allowsCustomValue?: boolean;
       /** Shown in the list when no item matches, the list stays closed if unset */
       emptyMessage?: ReactNode;
+      /**
+       * Whether an item is shown for the typed text, defaults to a case and
+       * accent insensitive match anywhere in its text. Pass false to show every
+       * item, eg. when the server already filtered them.
+       */
+      filter?: false | ((textValue: string, inputValue: string) => boolean);
+      /** Shows a spinner, eg. while the items for the typed text load */
+      loading?: boolean;
       /** Name of the hidden form input carrying the value */
       name?: string;
       autoFocus?: boolean;
-      /** ComboBoxItem elements */
+      /** ComboBoxItem and ComboBoxGroup elements */
       children: ReactNode;
   }
   /** A labelled text input that filters a list of options to pick from */
-  export function ComboBox({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, inputValue, defaultInputValue, onInputValueChange, open, defaultOpen, onOpenChange, placeholder, emptyMessage, autoFocus, className, style, children, ...props }: ComboBoxProps): import("react").JSX.Element;
+  export function ComboBox<V extends Key = Key>({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, inputValue, defaultInputValue, onInputValueChange, open, defaultOpen, onOpenChange, placeholder, emptyMessage, filter, loading, autoFocus, className, style, children, ...props }: ComboBoxProps<V>): import("react").JSX.Element;
   export interface ComboBoxItemProps extends StyleProps {
-      value: string;
+      value: Key;
       /** Text used for filtering and the input, defaults to string children */
       textValue?: string;
       disabled?: boolean;
+      /** Icon shown before the label in the list */
+      icon?: IconType | ReactElement;
+      /** Secondary text shown below the label in the list */
+      description?: ReactNode;
       children: ReactNode;
   }
   export function ComboBoxItem(props: ComboBoxItemProps): import("react").JSX.Element;
+  export interface ComboBoxGroupProps extends AriaProps {
+      label?: ReactNode;
+      children: ReactNode;
+  }
+  export function ComboBoxGroup(props: ComboBoxGroupProps): import("react").JSX.Element;
   
 }
 
@@ -2574,6 +2734,10 @@ declare module 'alinea/components/DateField' {
       min?: string;
       /** The latest valid date, `YYYY-MM-DD` */
       max?: string;
+      /**
+       * Name of the hidden form input, which submits the date like a native
+       * date input: `YYYY-MM-DD`, or an empty string when no date is set
+       */
       name?: string;
       autoFocus?: boolean;
   }
@@ -2633,12 +2797,15 @@ declare module 'alinea/components/Dialog' {
 
   import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
   import { type ButtonProps } from 'alinea/components/Button';
+  import { type FormProps } from 'alinea/components/Form';
   import { type TriggerProps } from 'alinea/components/internal/Trigger';
-  import type { AriaProps, DataProps, OpenStateProps, StyleProps } from 'alinea/components/types';
+  import type { AriaProps, DataProps, OpenStateProps, StyleProps, ValidationErrors } from 'alinea/components/types';
   export interface DialogProps extends OpenStateProps {
+      /** Called when the dialog closes, after `onOpenChange(false)` */
+      onClose?: () => void;
       children: ReactNode;
   }
-  export function Dialog({ open, defaultOpen, onOpenChange, children }: DialogProps): import("react").JSX.Element;
+  export function Dialog({ open, defaultOpen, onOpenChange, onClose, children }: DialogProps): import("react").JSX.Element;
   export interface DialogTriggerProps extends TriggerProps {
   }
   export function DialogTrigger(props: DialogTriggerProps): import("react").JSX.Element;
@@ -2654,9 +2821,17 @@ declare module 'alinea/components/Dialog' {
       dismissable?: boolean;
       /** Defaults to true */
       showCloseButton?: boolean;
+      /**
+       * Renders the content as a Form, submitted by a `type="submit"` Button.
+       * The dialog closes once this resolves without returning errors, which
+       * are shown on the fields otherwise.
+       */
+      onSubmit?: FormProps['onSubmit'];
+      /** Errors keyed by field name, when the content is a form */
+      validationErrors?: ValidationErrors;
       children: ReactNode;
   }
-  export function DialogContent({ role, size, dismissable, showCloseButton, className, style, children, id, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledby, 'aria-describedby': ariaDescribedby, ...props }: DialogContentProps): import("react").JSX.Element;
+  export function DialogContent({ role, size, dismissable, showCloseButton, onSubmit, validationErrors, className, style, children, id, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledby, 'aria-describedby': ariaDescribedby, ...props }: DialogContentProps): import("react").JSX.Element;
   export interface DialogHeaderProps extends ComponentPropsWithoutRef<'div'> {
   }
   export function DialogHeader({ className, ...props }: DialogHeaderProps): import("react").JSX.Element;
@@ -2854,7 +3029,7 @@ declare module 'alinea/components/Empty' {
 
 declare module 'alinea/components/Field' {
 
-  import type { ReactNode } from 'react';
+  import { type ReactNode } from 'react';
   import type { FieldSharedProps, StyleProps } from 'alinea/components/types';
   export interface FieldProps extends FieldSharedProps, StyleProps {
       /** Id of the control the label describes, not needed inside our inputs */
@@ -2928,6 +3103,34 @@ declare module 'alinea/components/FoldIcon' {
   
 }
 
+declare module 'alinea/components/Form' {
+
+  import { type ReactNode } from 'react';
+  import type { AriaProps, DataProps, StyleProps, ValidationErrors } from 'alinea/components/types';
+  export type FormSubmitResult = ValidationErrors | undefined | void;
+  export interface FormProps extends StyleProps, AriaProps, DataProps {
+      /**
+       * Errors keyed by field name, eg. from the server. A field shows its
+       * error until it is edited.
+       */
+      validationErrors?: ValidationErrors;
+      /**
+       * Called with the form data instead of submitting the form natively.
+       * Errors it returns are shown on the fields, next to `validationErrors`.
+       */
+      onSubmit?: (data: FormData) => FormSubmitResult | Promise<FormSubmitResult>;
+      children: ReactNode;
+  }
+  /**
+   * A form whose fields show validation errors: native constraints such as
+   * `required` once the form is submitted, and `validationErrors` or the
+   * errors returned by `onSubmit` by field name. An `error` set on a field
+   * itself takes precedence.
+   */
+  export function Form({ validationErrors, onSubmit, className, children, ...props }: FormProps): import("react").JSX.Element;
+  
+}
+
 declare module 'alinea/components/Heading' {
 
   import { type ReactNode } from 'react';
@@ -3012,14 +3215,38 @@ declare module 'alinea/components/internal/DateValue' {
   
 }
 
+declare module 'alinea/components/internal/FormScope' {
+
+  /** Set inside a Form, where fields show the validation errors of react-aria */
+  export const FormScope: import("react").Context<boolean>;
+  
+}
+
+declare module 'alinea/components/internal/ListBoxGroup' {
+
+  import type { ReactNode } from 'react';
+  import type { AriaProps } from 'alinea/components/types';
+  export interface ListBoxGroupProps extends AriaProps {
+      /** data-slot of the group, eg. "select-group" */
+      slot: string;
+      /** data-slot of its label */
+      labelSlot: string;
+      label?: ReactNode;
+      children: ReactNode;
+  }
+  /** A labelled group of options in the listbox of a Select or ComboBox */
+  export function ListBoxGroup({ slot, labelSlot, label, children, ...props }: ListBoxGroupProps): import("react").JSX.Element;
+  
+}
+
 declare module 'alinea/components/internal/ListBoxOption' {
 
   import type { CSSProperties, ReactElement, ReactNode } from 'react';
-  import type { IconType } from 'alinea/components/types';
+  import type { IconType, Key } from 'alinea/components/types';
   export interface ListBoxOptionProps {
       /** Prefix for the data-slot attributes, eg. "select-item" */
       slot: string;
-      value: string;
+      value: Key;
       textValue?: string;
       disabled?: boolean;
       icon?: IconType | ReactElement;
@@ -3226,13 +3453,20 @@ declare module 'alinea/components/Kbd' {
 
 declare module 'alinea/components/Link' {
 
-  import type { MouseEvent, ReactNode, Ref } from 'react';
+  import type { HTMLAttributeReferrerPolicy, MouseEvent, ReactNode, Ref } from 'react';
   import type { AriaProps, DataProps, StyleProps } from 'alinea/components/types';
   export interface LinkProps extends StyleProps, AriaProps, DataProps {
       href?: string;
       target?: string;
       rel?: string;
       download?: boolean | string;
+      /** Tooltip text */
+      title?: string;
+      tabIndex?: number;
+      lang?: string;
+      hrefLang?: string;
+      referrerPolicy?: HTMLAttributeReferrerPolicy;
+      'aria-current'?: boolean | 'page' | 'step' | 'location' | 'date' | 'time';
       /** `plain` underlines on hover, `underline` is always underlined */
       variant?: 'plain' | 'underline';
       disabled?: boolean;
@@ -3348,15 +3582,20 @@ declare module 'alinea/components/MediaPreview' {
 declare module 'alinea/components/MultipleSelect' {
 
   import { type ReactNode } from 'react';
-  import type { AriaProps, DataProps, FieldSharedProps, OpenStateProps, StyleProps } from 'alinea/components/types';
-  export interface MultipleSelectProps extends FieldSharedProps, OpenStateProps, StyleProps, AriaProps, DataProps {
-      value?: Array<string>;
-      defaultValue?: Array<string>;
-      onValueChange?: (value: Array<string>) => void;
+  import type { AriaProps, DataProps, FieldSharedProps, Key, OpenStateProps, StyleProps } from 'alinea/components/types';
+  export interface MultipleSelectProps<V extends Key = Key> extends FieldSharedProps, OpenStateProps, StyleProps, AriaProps, DataProps {
+      /** The values of the selected MultipleSelectItems */
+      value?: Array<V>;
+      defaultValue?: Array<V>;
+      onValueChange?: (value: Array<V>) => void;
       placeholder?: string;
       /** Shown in the list when no item matches the search, defaults to "No options" */
       emptyMessage?: ReactNode;
-      /** Name of the hidden form input carrying the values */
+      /**
+       * Name of the hidden form input carrying the values, it submits one entry
+       * per selected value like a native multiple select: read them with
+       * `formData.getAll(name)`
+       */
       name?: string;
       /** MultipleSelectItem elements */
       children: ReactNode;
@@ -3365,9 +3604,9 @@ declare module 'alinea/components/MultipleSelect' {
    * A labelled field to pick several values from a searchable list, the
    * selected values are shown as removable tags.
    */
-  export function MultipleSelect({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, open, defaultOpen, onOpenChange, placeholder, emptyMessage, className, style, children, ...props }: MultipleSelectProps): import("react").JSX.Element;
+  export function MultipleSelect<V extends Key = Key>({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, open, defaultOpen, onOpenChange, placeholder, emptyMessage, className, style, children, ...props }: MultipleSelectProps<V>): import("react").JSX.Element;
   export interface MultipleSelectItemProps extends StyleProps {
-      value: string;
+      value: Key;
       /** Text used for searching and the tag, defaults to string children */
       textValue?: string;
       disabled?: boolean;
@@ -3435,6 +3674,10 @@ declare module 'alinea/components/NumberField' {
       min?: number;
       max?: number;
       step?: number;
+      /**
+       * How the number is shown and parsed. Digits are not grouped unless
+       * `useGrouping` is set: number fields often hold years and ids
+       */
       formatOptions?: Intl.NumberFormatOptions;
       placeholder?: string;
       /** Show increment and decrement buttons, defaults to true */
@@ -3445,7 +3688,7 @@ declare module 'alinea/components/NumberField' {
       onFocus?: (event: FocusEvent<HTMLInputElement>) => void;
       onKeyDown?: (event: KeyboardEvent<HTMLInputElement>) => void;
   }
-  export function NumberField({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, min, max, placeholder, steppers, onBlur, onFocus, onKeyDown, className, ...props }: NumberFieldProps): import("react").JSX.Element;
+  export function NumberField({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, min, max, formatOptions, placeholder, steppers, onBlur, onFocus, onKeyDown, className, ...props }: NumberFieldProps): import("react").JSX.Element;
   
 }
 
@@ -3741,13 +3984,16 @@ declare module 'alinea/components/SearchField' {
 declare module 'alinea/components/Select' {
 
   import { type ReactElement, type ReactNode } from 'react';
-  import type { AriaProps, DataProps, FieldSharedProps, IconType, OpenStateProps, StyleProps } from 'alinea/components/types';
-  export interface SelectProps extends FieldSharedProps, OpenStateProps, StyleProps, AriaProps, DataProps {
-      value?: string | null;
-      defaultValue?: string | null;
+  import type { AriaProps, DataProps, FieldSharedProps, IconType, Key, OpenStateProps, StyleProps } from 'alinea/components/types';
+  export interface SelectProps<V extends Key = Key> extends FieldSharedProps, OpenStateProps, StyleProps, AriaProps, DataProps {
+      /** The value of the selected SelectItem */
+      value?: V | null;
+      defaultValue?: V | null;
       /** Called with the selected value, or null when the value is cleared */
-      onValueChange?: (value: string | null) => void;
+      onValueChange?: (value: V | null) => void;
       placeholder?: string;
+      /** Show a button that clears the value */
+      clearable?: boolean;
       /** Name of the hidden form input carrying the value */
       name?: string;
       autoFocus?: boolean;
@@ -3757,12 +4003,12 @@ declare module 'alinea/components/Select' {
       children: ReactNode;
   }
   /**
-   * A labelled field to pick a single value from a list. The value can be
-   * cleared unless the field is required.
+   * A labelled field to pick a single value from a list. Set `clearable` to
+   * let the value be cleared again.
    */
-  export function Select({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, open, defaultOpen, onOpenChange, placeholder, size, className, style, children, ...props }: SelectProps): import("react").JSX.Element;
+  export function Select<V extends Key = Key>({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, open, defaultOpen, onOpenChange, placeholder, clearable, size, className, style, children, ...props }: SelectProps<V>): import("react").JSX.Element;
   export interface SelectItemProps extends StyleProps {
-      value: string;
+      value: Key;
       disabled?: boolean;
       icon?: IconType | ReactElement;
       /** Text used for typeahead and the value, defaults to string children */
@@ -3776,7 +4022,7 @@ declare module 'alinea/components/Select' {
       label?: ReactNode;
       children: ReactNode;
   }
-  export function SelectGroup({ label, children, ...props }: SelectGroupProps): import("react").JSX.Element;
+  export function SelectGroup(props: SelectGroupProps): import("react").JSX.Element;
   export function SelectSeparator(): import("react").JSX.Element;
   
 }
@@ -3999,6 +4245,31 @@ declare module 'alinea/components/Spinner' {
   
 }
 
+declare module 'alinea/components/Stack' {
+
+  import type { ReactNode, Ref } from 'react';
+  import type { AriaProps, DataProps, StyleProps } from 'alinea/components/types';
+  export interface StackProps extends StyleProps, AriaProps, DataProps {
+      /** Defaults to `column` */
+      direction?: 'row' | 'column';
+      /** Space between the items, a number is in pixels */
+      gap?: number | string;
+      /** Cross axis alignment of the items, they stretch by default */
+      align?: 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+      /** Main axis distribution of the items */
+      justify?: 'start' | 'center' | 'end' | 'between';
+      /** Wrap items onto multiple lines */
+      wrap?: boolean;
+      /** Lay out the single child element instead of rendering a div */
+      asChild?: boolean;
+      ref?: Ref<HTMLDivElement>;
+      children?: ReactNode;
+  }
+  /** Lays out its children in a row or column with a gap between them */
+  export function Stack({ direction, gap, align, justify, wrap, asChild, className, style, ...props }: StackProps): import("react").JSX.Element;
+  
+}
+
 declare module 'alinea/components/Surface' {
 
   import type { ComponentPropsWithoutRef } from 'react';
@@ -4086,6 +4357,16 @@ declare module 'alinea/components/Table' {
        */
       onRowAction?: (key: Key) => void;
       renderEmptyState?: () => ReactNode;
+      /**
+       * Shows a spinner in place of the rows while there are none, below the
+       * rows otherwise
+       */
+      loading?: boolean;
+      /**
+       * Called when the rows are scrolled close to the end, to load the next
+       * page (see useAsyncList)
+       */
+      onLoadMore?: () => void;
       /**
        * Rows are cached per item, list the values `children` reads besides the
        * item to render them again when those change
@@ -4093,7 +4374,7 @@ declare module 'alinea/components/Table' {
       dependencies?: ReadonlyArray<unknown>;
       children: (item: T) => ReactElement;
   }
-  export function Table<T extends object>({ items, columns, showHeader, expandable, rowHeight, selectionMode, selectionBehavior, showSelectionControls, variant, selectedKeys, defaultSelectedKeys, onSelectionChange, disabledKeys, expandedKeys, defaultExpandedKeys, onExpandedChange, sortDescriptor, onSortChange, onRowAction, renderEmptyState, dependencies, getDragData, acceptedDragTypes, canDrop, onReorder, onMove, onDropItems, onDropFiles, renderDragPreview, className, style, children, ...props }: TableProps<T>): import("react").JSX.Element;
+  export function Table<T extends object>({ items, columns, showHeader, expandable, rowHeight, selectionMode, selectionBehavior, showSelectionControls, variant, selectedKeys, defaultSelectedKeys, onSelectionChange, disabledKeys, expandedKeys, defaultExpandedKeys, onExpandedChange, sortDescriptor, onSortChange, onRowAction, renderEmptyState, loading, onLoadMore, dependencies, getDragData, acceptedDragTypes, canDrop, onReorder, onMove, onDropItems, onDropFiles, renderDragPreview, className, style, children, ...props }: TableProps<T>): import("react").JSX.Element;
   export interface TableRowProps extends DataProps {
       id: Key;
       /** Text used for typeahead and as the accessible row name */
@@ -4261,6 +4542,8 @@ declare module 'alinea/components/TextField' {
       multiline?: boolean;
       /** Minimum number of rows of a multiline field */
       rows?: number;
+      /** Maximum number of rows a multiline field grows to before it scrolls */
+      maxRows?: number;
       /** Icon displayed inside the input, before the text */
       startIcon?: IconType | ReactElement;
       /** Icon displayed inside the input, after the text */
@@ -4270,6 +4553,10 @@ declare module 'alinea/components/TextField' {
       autoComplete?: string;
       maxLength?: number;
       minLength?: number;
+      /** Which virtual keyboard to show, eg. `numeric` for a code */
+      inputMode?: 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
+      /** A regular expression the value must match to be valid */
+      pattern?: string;
       onBlur?: (event: FocusEvent<TextFieldElement>) => void;
       onFocus?: (event: FocusEvent<TextFieldElement>) => void;
       onKeyDown?: (event: KeyboardEvent<TextFieldElement>) => void;
@@ -4277,7 +4564,7 @@ declare module 'alinea/components/TextField' {
       inputProps?: DataProps;
       ref?: Ref<HTMLDivElement>;
   }
-  export function TextField({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, placeholder, type, multiline, rows, startIcon, endIcon, autoComplete, maxLength, minLength, onBlur, onFocus, onKeyDown, inputProps, className, style, ...props }: TextFieldProps): import("react").JSX.Element;
+  export function TextField({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, placeholder, type, multiline, rows, maxRows, startIcon, endIcon, autoComplete, maxLength, minLength, onBlur, onFocus, onKeyDown, inputProps, className, style, ...props }: TextFieldProps): import("react").JSX.Element;
   export {};
   
 }
@@ -4301,10 +4588,15 @@ declare module 'alinea/components/TimeField' {
       granularity?: 'minute' | 'second';
       /** Defaults to the locale's hour cycle */
       hourCycle?: 12 | 24;
+      /**
+       * Name of the hidden form input, which submits the time like a native
+       * time input: `HH:mm`, or `HH:mm:ss` when granularity is `second`, and an
+       * empty string when no time is set
+       */
       name?: string;
       autoFocus?: boolean;
   }
-  export function TimeField({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, min, max, granularity, className, locale, ...props }: TimeFieldProps): import("react").JSX.Element;
+  export function TimeField({ label, description, error, required, disabled, readOnly, icon, shared, value, defaultValue, onValueChange, min, max, granularity, name, className, locale, ...props }: TimeFieldProps): import("react").JSX.Element;
   
 }
 
@@ -4617,6 +4909,10 @@ declare module 'alinea/components/types' {
       renderDragPreview?: (items: Array<Record<string, string>>) => ReactNode;
   }
   export type ContentStatus = 'published' | 'draft' | 'unpublished' | 'archived' | 'untranslated';
+  /** Error messages keyed by the `name` of a form field */
+  export interface ValidationErrors {
+      [name: string]: string | Array<string>;
+  }
   
 }
 
@@ -4806,6 +5102,12 @@ declare module 'alinea/core/Config' {
   export namespace Config {
       function baseUrl(config: Config, env?: string): string | undefined;
       function handlerUrl(config: Config): string;
+      /**
+       * The handler as reached from server renders. There is no request to take
+       * an origin from in static renders, and reading one would make every route
+       * dynamic, so a relative handlerUrl needs a baseUrl.
+       */
+      function serverHandlerUrl(config: Config, env?: string): URL;
       function adminPath(config: Config): string;
       function filePathname(config: Config, file: string): string;
       function dashboardFile(config: Config): string;
@@ -4960,6 +5262,30 @@ declare module 'alinea/core/Connection' {
   
 }
 
+declare module 'alinea/core/DashboardEntry' {
+
+  import type { OverviewEntry } from 'alinea/core/Overview';
+  /** The entry a dashboard view renders for, eg. the entry being edited */
+  export interface DashboardEntry<Data = Record<string, unknown>> extends OverviewEntry {
+      /**
+       * The field values of the selected version as saved. Unsaved edits are not
+       * included: read the live value of a field with `useFieldValue(field)`.
+       */
+      data: Data;
+  }
+  /** Props of an entry `actions` view, rendered in the entry header */
+  export interface EntryActionProps {
+      /** The entry being edited, in the selected version */
+      entry: DashboardEntry;
+      /**
+       * The locale the entry is edited in, which differs from `entry.locale`
+       * while a translation is not saved yet
+       */
+      locale: string | null;
+  }
+  
+}
+
 declare module 'alinea/core/db/CommitRequest' {
 
   import type { Change, ChangeFile, ChangesBatch } from 'alinea/core/source/Change';
@@ -5115,6 +5441,13 @@ declare module 'alinea/core/db/LocalStore' {
   export interface SyncOptions {
       /** Skip entry validation for a remote whose entries were already validated. */
       validate?: boolean;
+      /** Called as files arrive from the remote, once there are files to fetch. */
+      onProgress?(progress: SyncProgress): void;
+  }
+  /** Files fetched from the remote during a sync. */
+  export interface SyncProgress {
+      loaded: number;
+      total: number;
   }
   /**
    * A locally available entry store: a writeable graph backed by a source that
@@ -5422,13 +5755,13 @@ declare module 'alinea/core/Document' {
       path: PathField;
       metadata: MetadataField;
   };
-  export type DocumentConfig<Fields, Seo, Details> = (TypeConfig<Fields> | ContainerTypeConfig<Fields>) & {
+  export type DocumentConfig<Fields, Seo, Details, Settings = {}> = (TypeConfig<Fields, Settings> | ContainerTypeConfig<Fields, Settings>) & {
       /** Fields shown in the SEO tab, above the previews */
       seo?: Seo;
       /** Fields shown in the Details tab, above the created and updated details */
       details?: Details;
   };
-  export function document<Fields extends FieldsDefinition = {}, Seo extends FieldsDefinition = {}, Details extends FieldsDefinition = {}>(label: string, { fields, seo, details, ...config }: DocumentConfig<Fields, Seo, Details>): Type<Document & Fields & Seo & Details>;
+  export function document<Fields extends FieldsDefinition = {}, Seo extends FieldsDefinition = {}, Details extends FieldsDefinition = {}, Settings extends FieldsDefinition = {}>(label: string, { fields, seo, details, settings, ...config }: DocumentConfig<Fields, Seo, Details, Settings>): Type<Document & Fields & Seo & Details & Settings>;
   /** Whether `type` was created with `Config.document` */
   export function isDocument(type: Type): boolean;
   
@@ -5533,6 +5866,7 @@ declare module 'alinea/core/Entry' {
 declare module 'alinea/core/EntryFields' {
 
   import type { EntryStatus } from 'alinea/core/Entry';
+  import type { Related } from 'alinea/core/Filter';
   export interface EntryFields {
       _id: string;
       _type: string;
@@ -5550,8 +5884,13 @@ declare module 'alinea/core/EntryFields' {
   }
   /** The fields filters can match, next to those of the entry */
   export interface EntryFilterFields extends EntryFields {
-      /** Whether another entry links to the entry */
-      _referenced: boolean;
+      /**
+       * Whether another entry links to the entry, or an entry that matches a
+       * query, eg. `{_referenced: Query.referencedBy({type: Product})}`
+       */
+      _referenced: Related<{
+          edge: 'referencedBy';
+      }>;
   }
   export const EntryFields: {
       _id: import("alinea/core/Expr").Expr<string>;
@@ -5722,6 +6061,11 @@ declare module 'alinea/core/Field' {
       required?: boolean;
       /** Validate the given value */
       validate?(value: StoredValue): boolean | string | undefined;
+      /**
+       * The width of the field in the entry form, a fraction between 0 and 1.
+       * Fields that fit next to each other share a row.
+       */
+      width?: number;
   }
   export interface EntryAnchorTarget {
       id: string;
@@ -5825,8 +6169,7 @@ declare module 'alinea/core/field/CreateField' {
   import type { Field, FieldOptions, WithoutLabel } from 'alinea/core/Field';
   import type { Expand } from 'alinea/core/util/Types';
   import type { View } from 'alinea/core/View';
-  export interface Create<Value, Options = object> extends Field<Value, Value, (value: Value) => void, FieldOptions<Value> & Options> {
-  }
+  export type Create<Value, Options = object> = Field<Value, Value, (value: Value) => void, FieldOptions<Value> & Options>;
   export type Options<F> = Expand<F extends Field<any, any, any, infer Options> ? WithoutLabel<Options & FieldOptions<any>> : WithoutLabel<FieldOptions<any>>>;
   export interface CreateConfig<Value, Options> {
       label: string;
@@ -5980,12 +6323,24 @@ declare module 'alinea/core/Filter' {
   interface ArrayOps<Fields> {
       includes?: Filter<Fields>;
   }
+  const related: unique symbol;
+  /**
+   * A field matched by a query of related entries, eg. `_referenced`. Its
+   * condition holds when the query finds an entry.
+   */
+  export interface Related<Query> {
+      [related]: Query;
+  }
+  /** A query of related entries used as a condition */
+  export interface RelationCondition {
+      edge: string;
+  }
   type FieldOps<Fields> = {
       [K in keyof Fields]?: Condition<Fields[K]>;
   };
-  export type Condition<Value> = [Value] extends [Primitive] ? Ops<Value> | Value : [Value] extends [Array<any>] ? ArrayOps<Value[0]> : ObjectOps<Value>;
+  export type Condition<Value> = [Value] extends [Related<infer Query>] ? Condition<boolean> | Query : [Value] extends [Primitive] ? Ops<Value> | Value : [Value] extends [Array<any>] ? ArrayOps<Value[0]> : ObjectOps<Value>;
   /** A condition on a field whose type is not known */
-  export type AnyCondition = Primitive | Ops<unknown> | ArrayOps<unknown> | ObjectOps<unknown>;
+  export type AnyCondition = Primitive | Ops<unknown> | ArrayOps<unknown> | ObjectOps<unknown> | RelationCondition;
   /**
    * A filter on known fields that also accepts conditions on any other field,
    * for example the fields of the entry types an entry picker can select
@@ -6038,6 +6393,11 @@ declare module 'alinea/core/Filter' {
   } | {
       op: 'includes';
       item: ConditionNode;
+  }
+  /** Holds when the query of related entries finds an entry */
+   | {
+      op: 'relation';
+      query: RelationCondition;
   };
   export function parseFilter(filter: unknown): FilterNode;
   export function parseCondition(condition: unknown): ConditionNode;
@@ -6098,7 +6458,15 @@ declare module 'alinea/core/Graph' {
       edge: 'entrySingle';
       field: HasField & Expr;
   }
-  export type Edge = EdgeTranslations | EdgeChildren | EdgeParents | EdgeSiblings | EdgeParent | EdgeNext | EdgePrevious | EdgeEntries | EdgeEntry;
+  /**
+   * Entries that link to the entry, through any field or through the given
+   * link field of their type
+   */
+  export interface EdgeReferencedBy {
+      edge: 'referencedBy';
+      field?: HasField & Expr;
+  }
+  export type Edge = EdgeTranslations | EdgeChildren | EdgeParents | EdgeSiblings | EdgeParent | EdgeNext | EdgePrevious | EdgeEntries | EdgeEntry | EdgeReferencedBy;
   /** Options that change a query result into a single entry or a count */
   export interface QueryModifiers {
       first?: true;
@@ -6247,7 +6615,7 @@ declare module 'alinea/core/Graph' {
       get<Selection extends SelectionGuard = undefined, const Type extends TypeGuard = undefined, Include extends IncludeGuard = undefined>(query: GraphQuery<Selection, Type, Include>): Promise<QueryResult<Selection, Type, Include>>;
       count<Selection extends SelectionGuard = undefined, const Type extends TypeGuard = undefined, Include extends IncludeGuard = undefined>(query: GraphQuery<Selection, Type, Include>): Promise<number>;
   }
-  export function querySource(query: unknown): "children" | "entryMultiple" | "entrySingle" | "next" | "parent" | "parents" | "previous" | "siblings" | "translations" | undefined;
+  export function querySource(query: unknown): "children" | "entryMultiple" | "entrySingle" | "next" | "parent" | "parents" | "previous" | "referencedBy" | "siblings" | "translations" | undefined;
   export {};
   
 }
@@ -6834,7 +7202,7 @@ declare module 'alinea/core/Overview' {
   import type { EntryFilterFields } from 'alinea/core/EntryFields';
   import { Expr } from 'alinea/core/Expr';
   import type { OpenFilter } from 'alinea/core/Filter';
-  import type { EdgeQuery, GraphQuery, InferProjection, Order, Projection } from 'alinea/core/Graph';
+  import type { EdgeQuery, Graph, GraphQuery, InferProjection, Order, Projection } from 'alinea/core/Graph';
   import type { Type } from 'alinea/core/Type';
   import type { View } from 'alinea/core/View';
   /** Horizontal alignment of a column's header and cells */
@@ -6844,9 +7212,10 @@ declare module 'alinea/core/Overview' {
   /** A fixed width in pixels or a fraction of the remaining space */
   export type OverviewColumnWidth = number | `${number}fr`;
   /**
-   * A value to sort entries by: an expression such as a field, or a query of a
+   * A value to sort entries by: an expression such as a field, a query of a
    * linked entry that selects a single expression, eg.
-   * `Product.brand.first({select: Entry.title})`
+   * `Product.brand.first({select: Entry.title})`, or a count of related
+   * entries, eg. `Query.referencedBy({type: Product, count: true})`
    */
   export type OverviewSortValue = Expr<any> | EdgeQuery<Expr<any>>;
   /** One projection per entry type, keyed by the type names of the schema */
@@ -6931,12 +7300,39 @@ declare module 'alinea/core/Overview' {
       /** The condition entries match when the option is picked */
       filter: OpenFilter<EntryFilterFields>;
   }
+  /** The choices of an overview filter, keyed by a name unique within it */
+  export interface OverviewFilterOptions {
+      [key: string]: OverviewFilterOption;
+  }
+  /** What the options of an overview filter can be loaded with */
+  export interface OverviewFilterContext {
+      /** Query the content, eg. to list an option per entry of a type */
+      graph: Graph;
+      /** The locale the overview lists, null for unlocalised roots */
+      locale: string | null;
+  }
   /** A filter editors can apply in the "Filter and sort" menu of an overview */
   export interface OverviewFilter {
       /** The heading of the options in the menu, eg. `File type` */
       label: string;
-      /** The choices, keyed by a name that is unique within the filter */
-      options: Record<string, OverviewFilterOption>;
+      /**
+       * The choices, keyed by a name that is unique within the filter, or a
+       * function that loads them, eg. an option per category:
+       *
+       * ```ts
+       * async options({graph}) {
+       *   const categories = await graph.find({
+       *     type: Category,
+       *     select: {id: Entry.id, title: Entry.title}
+       *   })
+       *   return Object.fromEntries(categories.map(category => [category.id, {
+       *     label: category.title,
+       *     filter: {category: {has: {_entry: category.id}}}
+       *   }]))
+       * }
+       * ```
+       */
+      options: OverviewFilterOptions | ((context: OverviewFilterContext) => OverviewFilterOptions | Promise<OverviewFilterOptions>);
       /**
        * Editors can pick several options, entries then match any of them.
        * Defaults to false: picking an option replaces the picked one.
@@ -6960,6 +7356,36 @@ declare module 'alinea/core/Overview' {
        */
       query: GraphQuery<undefined, Type | Array<Type> | undefined, undefined>;
   }
+  /** A tab above the listed entries, each lists the entries of its filter */
+  export interface OverviewTab {
+      /** Shown on the tab, eg. `Active` */
+      label: string;
+      /**
+       * The condition entries match when the tab is selected, like the options of
+       * a filter. A tab without a filter lists every child.
+       */
+      filter?: OpenFilter<EntryFilterFields>;
+  }
+  /** Props of an `overview.header` view */
+  export interface OverviewHeaderProps {
+      workspace: string;
+      root: string;
+      /** The entry whose children are listed, null for the root */
+      parentId: string | null;
+      locale: string | null;
+      /** The search terms entered in the overview */
+      search: string;
+      /**
+       * The condition of the selected tab and the applied filters, undefined
+       * when none applies
+       */
+      filter: OpenFilter<EntryFilterFields> | undefined;
+      /**
+       * A query for the listed entries, without paging. Pass it to
+       * `useGraph().find({...query, select})`, eg. to total them.
+       */
+      query: GraphQuery<undefined, Type | Array<Type> | undefined, undefined>;
+  }
   interface OverviewColumnBase<Value> {
       /** The column header */
       header: string;
@@ -7044,6 +7470,12 @@ declare module 'alinea/core/Overview' {
        * applied filter, and the search terms.
        */
       filters?: Record<string, OverviewFilter>;
+      /**
+       * Tabs above the listed children, keyed by a name kept in the url. The
+       * first tab is selected by default. Entries match the filter of the
+       * selected tab, the applied filters and the search terms.
+       */
+      tabs?: Record<string, OverviewTab>;
       /** The default layout, editors can still switch */
       layout?: 'table' | 'cards';
       /**
@@ -7053,6 +7485,11 @@ declare module 'alinea/core/Overview' {
       thumbnail?: Expr<any> | Record<string, Expr<any>>;
       /** Components rendered in the overview toolbar, eg. an export button */
       actions?: Array<View<OverviewActionProps>>;
+      /**
+       * A component rendered above the listed children, eg. totals or a chart of
+       * the listed entries
+       */
+      header?: View<OverviewHeaderProps>;
   }
   /** Create a column for an overview */
   export function column<const Select extends OverviewColumnSelect | undefined = undefined>(options: OverviewColumnOptions<Select, OverviewColumnValue<Select>>): OverviewColumn<OverviewColumnValue<Select>>;
@@ -7489,6 +7926,11 @@ declare module 'alinea/core/Scope' {
       fieldOf(field: Field): [type: string, path: string] | undefined;
       locationOf(entity: Entity): string[] | undefined;
       nameOf(entity: Entity): string | undefined;
+      /**
+       * Where a field stores its value in the entry data, eg. `['seo', 'title']`
+       * for a field of an object field
+       */
+      dataPathOf(field: Field): Array<string> | undefined;
       /** Configured spellings of a locale, matched case-insensitively. */
       locales(locale: string): Array<string>;
       stringify(input: any): string;
@@ -7836,6 +8278,8 @@ declare module 'alinea/core/source/Source' {
       /** Consume remote blobs incrementally instead of materializing one bundle. */
       applyChangesFrom?(remote: RemoteSource, batch: ChangesBatch, tree: ReadonlyTree): Promise<void>;
   }
+  /** Pin the tree while streaming blobs from the revision already fetched. */
+  export function sourceAtTree(source: RemoteSource, tree: ReadonlyTree): RemoteSource;
   export function applyChangesFrom(source: Source, remote: RemoteSource, batch: ChangesBatch, tree: ReadonlyTree): Promise<void>;
   export function bundleContents(source: RemoteSource, batch: ChangesBatch): Promise<ChangesBatch>;
   export function diff(source: Source, remote: RemoteSource): Promise<ChangesBatch>;
@@ -8182,6 +8626,7 @@ declare module 'alinea/core/Trigger' {
 
 declare module 'alinea/core/Type' {
 
+  import type { EntryActionProps } from 'alinea/core/DashboardEntry';
   import type { ComponentType } from 'react';
   import type { Config } from 'alinea/core/Config';
   import type { EntryStatus } from 'alinea/core/Entry';
@@ -8231,6 +8676,8 @@ declare module 'alinea/core/Type' {
       function references(type: Type, value: Record<string, unknown>, path?: Array<string>, labels?: Array<string>): Array<EntryReferenceTarget>;
       function fields(type: Type): Record<string, Field>;
       function sections(type: Type): Section[];
+      /** Fields edited in the settings of a block, or a Settings tab of an entry */
+      function settings(type: Type): FieldsDefinition | undefined;
       function isContainer(type: Type): boolean;
       function field(type: Type, name: string): Field | undefined;
       function isType(type: any): type is Type;
@@ -8249,12 +8696,24 @@ declare module 'alinea/core/Type' {
   export interface FieldsDefinition {
       [key: string]: Field;
   }
-  export interface TypeConfig<Definition> {
+  export interface TypeConfig<Definition, Settings = {}> {
       fields: Definition;
+      /**
+       * Fields shown in the settings sheet of a block, below its label and
+       * anchor. Entries of the type show them in a Settings tab. They are stored
+       * and queried like the other fields.
+       */
+      settings?: Settings;
       /** Accepts entries of these types as children */
       contains?: Array<string | Type>;
       /** How the dashboard lists the children of entries of this type */
       overview?: OverviewOptions;
+      /**
+       * Components rendered in the header of the entry editor, next to the
+       * publish button, eg. a button that exports or sends the entry. They can
+       * read the fields of the entry with the hooks of `alinea/cms`.
+       */
+      actions?: Array<View<EntryActionProps>>;
       /**
        * Order children entries in the sidebar content tree
        * @deprecated Use `overview.sort`
@@ -8272,7 +8731,11 @@ declare module 'alinea/core/Type' {
       collapsed?: boolean;
       /** An icon (React component) to represent this type in the dashboard */
       icon?: ComponentType;
-      /** A React component used to view an entry of this type in the dashboard */
+      /**
+       * A React component, or a path to one, that replaces the form of entries of
+       * this type below the entry header. It edits the fields of the entry with
+       * the hooks of `alinea/cms`.
+       */
       view?: View<{
           type: Type;
       }>;
@@ -8296,19 +8759,19 @@ declare module 'alinea/core/Type' {
       preview?: Preview;
   }
   /** Types that only hold children can leave out their fields */
-  export interface ContainerTypeConfig<Definition> extends Omit<TypeConfig<Definition>, 'fields' | 'contains'> {
+  export interface ContainerTypeConfig<Definition, Settings = {}> extends Omit<TypeConfig<Definition, Settings>, 'fields' | 'contains'> {
       fields?: Definition;
       /** Accepts entries of these types as children */
       contains: Array<string | Type>;
   }
-  export interface TypeInternal extends TypeConfig<FieldsDefinition> {
+  export interface TypeInternal extends TypeConfig<FieldsDefinition, FieldsDefinition> {
       label: string;
       allFields: Record<string, Field>;
       sections: Array<Section>;
   }
   /** Create a new type */
-  export function type<Fields extends FieldsDefinition = {}>(label: string, config: TypeConfig<Fields> | ContainerTypeConfig<Fields>): Type<Fields>;
-  export function createType<Fields extends FieldsDefinition = {}>(label: string, { fields: definition, ...config }: TypeConfig<Fields> | ContainerTypeConfig<Fields>): Type<Fields>;
+  export function type<Fields extends FieldsDefinition = {}, Settings extends FieldsDefinition = {}>(label: string, config: TypeConfig<Fields, Settings> | ContainerTypeConfig<Fields, Settings>): Type<Fields & Settings>;
+  export function createType<Fields extends FieldsDefinition = {}, Settings extends FieldsDefinition = {}>(label: string, { fields: definition, ...config }: TypeConfig<Fields, Settings> | ContainerTypeConfig<Fields, Settings>): Type<Fields & Settings>;
   export {};
   
 }
@@ -8391,6 +8854,8 @@ declare module 'alinea/core/util/Async' {
   /** Map concurrently while yielding results as they complete. */
   export function mapConcurrent<T, TResult>(iterable: Iterable<T>, mapper: (item: T, signal?: AbortSignal) => Promise<TResult>, options: MapConcurrentOptions): AsyncGenerator<TResult>;
   export function genEffect<T, TReturn>(gen: AsyncIterable<T, TReturn>, effect: (result: T) => void): AsyncIterable<T>;
+  /** Settle like `promise`, or reject when it takes longer than `ms`. */
+  export function within<T>(promise: Promise<T>, ms: number): Promise<T>;
   /** Run tasks one after another; a failed task does not block the next one. */
   export class TaskQueue {
       #private;
@@ -9180,6 +9645,7 @@ declare module 'alinea/dashboard/App' {
   }
   export const appAtom: import("jotai").Atom<readonly [false, string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | null | undefined] | readonly [true, string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | null | undefined]>;
   export function App(props: AppProps): import("react").JSX.Element;
+  export function AppLoading(): import("react").JSX.Element;
   
 }
 
@@ -9252,6 +9718,20 @@ declare module 'alinea/dashboard/app/AuthView' {
   
 }
 
+declare module 'alinea/dashboard/app/BlockSettings' {
+
+  import { Type } from 'alinea/core/Type';
+  import type { EditorNode } from 'alinea/dashboard/atoms/editor';
+  export interface BlockSettingsProps {
+      node: EditorNode;
+      type: Type;
+      readOnly?: boolean;
+  }
+  /** The settings fields of a block's type, for its settings sheet */
+  export function BlockSettings({ node, type, readOnly }: BlockSettingsProps): import("react").JSX.Element | null;
+  
+}
+
 declare module 'alinea/dashboard/app/BlockSheet' {
 
   import type { StyleProps } from 'alinea/components';
@@ -9384,7 +9864,7 @@ declare module 'alinea/dashboard/app/DashboardLayout' {
   import type { WorkspaceInternal } from 'alinea/core/Workspace';
   import type { Page } from 'alinea/dashboard/atoms/nav';
   import type { RootAtoms, TreeView } from 'alinea/dashboard/atoms/root';
-  import type { PropsWithChildren } from 'react';
+  import { type PropsWithChildren } from 'react';
   export interface DashboardLayoutProps extends PropsWithChildren {
       canManageMembers: boolean;
       page: Page;
@@ -9454,21 +9934,50 @@ declare module 'alinea/dashboard/app/editor/MediaAltField.view' {
   
 }
 
+declare module 'alinea/dashboard/app/EntryActions' {
+
+  import type { Entry } from 'alinea/core/Entry';
+  import type { Type } from 'alinea/core/Type';
+  import type { EditorNode } from 'alinea/dashboard/atoms/editor';
+  export interface EntryActionsProps {
+      type: Type;
+      node: EditorNode;
+      entry: Entry;
+      locale: string | null;
+  }
+  /** The actions configured with the `actions` option of a type */
+  export function EntryActions({ type, node, entry, locale }: EntryActionsProps): import("react").JSX.Element | null;
+  
+}
+
 declare module 'alinea/dashboard/app/EntryFields' {
 
   import { Field } from 'alinea/core/Field';
   import { Section } from 'alinea/core/Section';
+  import type { ObjectField } from 'alinea/field/object';
   export function FieldsEditor(): import("react").JSX.Element[];
   export function EntryFields(): import("react").JSX.Element[];
   export interface EditFieldsProps {
+      /**
+       * An object field to render the fields of, in the scope of its value.
+       * Without `fields` all its fields are rendered.
+       */
+      field?: ObjectField<object>;
       /** The fields and sections to render, keyed by name */
-      fields: Record<string, Field | Section>;
+      fields?: Record<string, Field | Section>;
   }
   /**
    * Renders a set of fields and sections with their configured views, laid out
    * like the default entry form (including each field's `width`).
+   *
+   * @example
+   * // Some fields of an object field, in a custom view of that object
+   * <EditFields
+   *   field={Product.dimensions}
+   *   fields={{width: Product.dimensions.width}}
+   * />
    */
-  export const EditFields: import("react").MemoExoticComponent<({ fields }: EditFieldsProps) => import("react").JSX.Element>;
+  export const EditFields: import("react").MemoExoticComponent<({ field, fields }: EditFieldsProps) => import("react").JSX.Element | null>;
   export interface EditFieldProps {
       /** The field to render, it must belong to the entry, row or object being edited */
       field: Field;
@@ -9882,6 +10391,17 @@ declare module 'alinea/dashboard/app/ExplorerModal' {
   
 }
 
+declare module 'alinea/dashboard/app/ExplorerOverviewHeader' {
+
+  import type { ReactNode } from 'react';
+  export interface ExplorerOverviewHeaderProps {
+      children: ReactNode;
+  }
+  /** Places the `overview.header` view between the toolbar and the list */
+  export function ExplorerOverviewHeader({ children }: ExplorerOverviewHeaderProps): import("react").JSX.Element;
+  
+}
+
 declare module 'alinea/dashboard/app/ExplorerPickerContent' {
 
   import { type DashboardEntry, type DashboardExplorer, type ExplorerLocation, type ExplorerOptions, type ExplorerReadyPage, type ExplorerView } from 'alinea/dashboard/atoms/explorer';
@@ -9939,6 +10459,23 @@ declare module 'alinea/dashboard/app/ExplorerTable' {
   
 }
 
+declare module 'alinea/dashboard/app/ExplorerTabs' {
+
+  import type { ReactNode } from 'react';
+  import type { OverviewTabState } from 'alinea/dashboard/atoms/overview';
+  export interface ExplorerTabsProps {
+      tabs: Array<OverviewTabState>;
+      /** The key of the selected tab */
+      value: string;
+      onValueChange: (value: string) => void;
+      /** The listed entries of the selected tab */
+      children: ReactNode;
+  }
+  /** The tabs of an overview, above the entries listed for the selected tab */
+  export function ExplorerTabs({ tabs, value, onValueChange, children }: ExplorerTabsProps): import("react").JSX.Element;
+  
+}
+
 declare module 'alinea/dashboard/app/ExternalLinkPicker' {
 
   export interface ExternalLinkValue {
@@ -10328,6 +10865,17 @@ declare module 'alinea/dashboard/app/SearchBar' {
   
 }
 
+declare module 'alinea/dashboard/app/SettingsTab' {
+
+  import { Type } from 'alinea/core/Type';
+  /**
+   * The type an entry's form renders: the settings of a type that is not a
+   * document (documents add their own tab) move to a Settings tab.
+   */
+  export function withSettingsTab(entryType: Type): Type;
+  
+}
+
 declare module 'alinea/dashboard/app/SidebarLayout' {
 
   import type { ReactNode } from 'react';
@@ -10497,6 +11045,7 @@ declare module 'alinea/dashboard/atoms/activity' {
   export interface DashboardActivity {
       items: Array<Activity>;
       isMutating: boolean;
+      isSyncing: boolean;
       hasFailed: boolean;
       hasBlocked: boolean;
       canRetry: boolean;
@@ -10594,8 +11143,10 @@ declare module 'alinea/dashboard/atoms/config' {
   export const viewAtoms: (key: string) => import("jotai").Atom<ComponentType | undefined>;
   export const typeAtoms: (typeName: string) => import("jotai").Atom<{
       fields: import("alinea/core/Type").FieldsDefinition;
+      settings?: import("alinea/core/Type").FieldsDefinition | undefined;
       contains?: Array<string | import("alinea/types").Type>;
       overview?: import("alinea/types").OverviewOptions;
+      actions?: Array<import("alinea/core/View").View<import("alinea/types").EntryActionProps>>;
       orderChildrenBy?: import("alinea/core/OrderBy").OrderBy | Array<import("alinea/core/OrderBy").OrderBy>;
       hidden?: true;
       collapsed?: boolean;
@@ -10693,6 +11244,17 @@ declare module 'alinea/dashboard/atoms/dashboard' {
   export const entrySidebarOpenAtom: import("jotai").PrimitiveAtom<boolean> & {
       init: boolean;
   };
+  /**
+   * Entries without a preview only have history and references in the sidebar,
+   * so it starts closed for them (like the 1.x preview pane) and remembers its
+   * own state, leaving the room to the form and wide custom views
+   */
+  export const entrySidebarOpenWithoutPreviewAtom: import("jotai").PrimitiveAtom<boolean> & {
+      init: boolean;
+  };
+  export function entrySidebarOpen(hasPreview: boolean): import("jotai").PrimitiveAtom<boolean> & {
+      init: boolean;
+  };
   export const themeAtom: import("jotai").WritableAtom<DashboardTheme, [update: SetStateAction<DashboardTheme>], void> & {
       onMount(setTheme: (update: SetStateAction<DashboardTheme>) => void): void;
   };
@@ -10739,8 +11301,12 @@ declare module 'alinea/dashboard/atoms/editor' {
       }> | ((props: {
           section: Section;
       }) => ReactNode) | undefined>;
+      /** The section has a view or at least one field that is not hidden */
+      visible: Atom<boolean>;
   }
   export interface EditorField {
+      /** The editor of the entry, row or object the field belongs to */
+      editor: EditorModel;
       key: string;
       value: WritableAtom<unknown, [unknown], void>;
       options: Atom<FieldOptions<unknown>>;
@@ -10768,13 +11334,15 @@ declare module 'alinea/dashboard/atoms/editor' {
   }
   export function rootEditor(editor: EditorModel): EditorModel;
   export class EntryEditorSection implements EditorSection {
+      editor: EditorModel;
       section: Section;
-      constructor(section: Section);
+      constructor(editor: EditorModel, section: Section);
       view: Atom<((props: {
           section: Section;
       }) => ReactNode) | ComponentType<{
           section: Section;
       }> | undefined>;
+      visible: Atom<boolean>;
   }
   class EntryEditorField implements EditorField {
       #private;
@@ -11079,6 +11647,7 @@ declare module 'alinea/dashboard/atoms/explorer' {
   import type { Config } from 'alinea/core/Config';
   import { type EntryStatus } from 'alinea/core/Entry';
   import type { EntryFields } from 'alinea/core/EntryFields';
+  import { type OpenFilter } from 'alinea/core/Filter';
   import type { Filter } from 'alinea/core/Filter';
   import type { GraphQuery } from 'alinea/core/Graph';
   import type { OverviewSort } from 'alinea/core/Overview';
@@ -11151,6 +11720,11 @@ declare module 'alinea/dashboard/atoms/explorer' {
        * explorer. The explorers of a root share them.
        */
       filterState?: PrimitiveAtom<OverviewFilterSelection>;
+      /**
+       * The key of the tab the editor picked, defaults to state kept by the
+       * explorer. Page explorers keep it in the url.
+       */
+      tabState?: WritableAtom<string | undefined, [string | undefined], void>;
       showSelectionControls?: boolean;
       initialSelection?: Array<string>;
       /**
@@ -11189,6 +11763,11 @@ declare module 'alinea/dashboard/atoms/explorer' {
   }
   export interface ExplorerReadyPage {
       canUpload: boolean;
+      /**
+       * The condition of the selected tab and the picked filters, undefined when
+       * none applies
+       */
+      filter: OpenFilter<EntryFields> | undefined;
       /** The filter options the listed entries match, by filter key */
       filters: OverviewFilterSelection;
       isMedia: boolean;
@@ -11206,6 +11785,8 @@ declare module 'alinea/dashboard/atoms/explorer' {
       searchScope: 'workspace' | 'everything';
       searchesEverything: boolean;
       sort: ExplorerSortState;
+      /** The key of the tab shown, undefined when the overview has no tabs */
+      tab: string | undefined;
       view: ExplorerView;
   }
   export function explorerPageIsPending(page: ExplorerReadyPage, location: ExplorerLocation, locale: string | null): boolean;
@@ -11393,6 +11974,8 @@ declare module 'alinea/dashboard/atoms/explorer' {
        * key. The page lists the ones that apply to its overview.
        */
       requestedFilters: PrimitiveAtom<OverviewFilterSelection>;
+      /** The key of the tab the editor picked, undefined for the first tab */
+      requestedTab: WritableAtom<string | undefined, [string | undefined], void>;
       selectedLocale: WritableAtom<string | null, [
           SetStateAction<string | null>
       ], void>;
@@ -11482,6 +12065,11 @@ declare module 'alinea/dashboard/atoms/explorer' {
 
 declare module 'alinea/dashboard/atoms/graph' {
 
+  import type { SyncProgress } from 'alinea/core/db/LocalStore';
+  /** The files fetched by a running sync from the remote. */
+  export const syncProgressAtom: import("jotai").WritableAtom<SyncProgress | undefined, [], () => void> & {
+      onMount: (init: () => () => void) => () => void;
+  };
   export const shaAtom: import("jotai").Atom<Promise<string | undefined>>;
   export const entryRevisionAtom: (id: string) => import("jotai").Atom<string | undefined>;
   export const syncAtom: import("jotai").WritableAtom<null, [], Promise<string | undefined>> & {
@@ -11636,6 +12224,8 @@ declare module 'alinea/dashboard/atoms/nav' {
   import type { OverviewSort } from 'alinea/core/Overview';
   import type { EntryDefaultView } from 'alinea/core/Type';
   import { ReactNode } from 'react';
+  import { nav } from 'alinea/dashboard/Href';
+  export { nav };
   export interface RouteBlock {
       confirm: () => void | Promise<void>;
   }
@@ -11646,7 +12236,10 @@ declare module 'alinea/dashboard/atoms/nav' {
       init: RouteBlock | null;
   };
   export interface DashboardRoute {
-      /** An edit link names an entry by its url, until it is looked up */
+      /**
+       * An edit link names an entry by its url, or by its id without workspace
+       * and root, until it is looked up
+       */
       page?: 'splash' | 'entry' | 'users' | 'edit';
       url?: string;
       workspace?: string;
@@ -11656,22 +12249,19 @@ declare module 'alinea/dashboard/atoms/nav' {
       view?: EntryDefaultView;
       /** The column an overview is sorted by, eg. `price` or `-price` */
       sort?: string;
+      /** The tab an overview shows, eg. `active` */
+      tab?: string;
       /** Replace the current history entry instead of adding one */
       replace?: boolean;
   }
-  interface ResolvedDashboardRoute extends DashboardRoute {
+  export interface ResolvedDashboardRoute extends DashboardRoute {
       page: 'splash' | 'entry' | 'users' | 'edit';
   }
-  export const nav: {
-      splash(): string;
-      users(): string;
-      /** The editor of the entry at `url`, as linked from a page of the site */
-      edit(url: string, workspace?: string, root?: string): string;
-      entry(workspace?: string, root?: string, entryId?: string, locale?: string | null, view?: EntryDefaultView, sort?: string): string;
-  };
   /** The url parameter of an overview sort: the column, prefixed with - when descending */
   export function formatOverviewSort(sort?: OverviewSort): string | undefined;
   export function parseOverviewSort(value: string | undefined): OverviewSort | undefined;
+  /** @internal */
+  export function hashFromRoute(route: ResolvedDashboardRoute): string;
   interface NavigationRequest {
       browser?: boolean;
       replace?: boolean;
@@ -11696,8 +12286,12 @@ declare module 'alinea/dashboard/atoms/nav' {
    * when `entry` is null. The overview of the current page keeps it in the url.
    */
   export const overviewSortAtom: (workspace: string, root: string, entry: string | null) => import("jotai").WritableAtom<OverviewSort | undefined, [sort: OverviewSort | undefined], void>;
+  /**
+   * The tab of the overview listing the children of an entry, or of a root
+   * when `entry` is null. The overview of the current page keeps it in the url.
+   */
+  export const overviewTabAtom: (workspace: string, root: string, entry: string | null) => import("jotai").WritableAtom<string | undefined, [tab: string | undefined], void>;
   export function page(render: (page: Page, get: Getter) => ReactNode | Promise<ReactNode>): (page: Page, get: Getter) => ReactNode | Promise<ReactNode>;
-  export {};
   
 }
 
@@ -11711,7 +12305,7 @@ declare module 'alinea/dashboard/atoms/overview' {
   import type { OrderBy } from 'alinea/core/OrderBy';
   import type { EntryFields } from 'alinea/core/EntryFields';
   import type { OpenFilter } from 'alinea/core/Filter';
-  import { type OverviewActionProps, type OverviewCellProps, type OverviewColumnAlign, type OverviewColumnWidth, type OverviewEntry, type OverviewFormatContext, type OverviewOptions, type OverviewSort, type OverviewSortDirection } from 'alinea/core/Overview';
+  import { type OverviewActionProps, type OverviewCellProps, type OverviewColumnAlign, type OverviewColumnWidth, type OverviewEntry, type OverviewFilterContext, type OverviewFilterOptions, type OverviewFormatContext, type OverviewHeaderProps, type OverviewOptions, type OverviewSort, type OverviewSortDirection } from 'alinea/core/Overview';
   import { type RootData } from 'alinea/core/Root';
   import { Type } from 'alinea/core/Type';
   import type { View } from 'alinea/core/View';
@@ -11770,7 +12364,16 @@ declare module 'alinea/dashboard/atoms/overview' {
       key: string;
       label: string;
       multiple: boolean;
+      /** The options, empty until `loadFilterOptions` loaded those of `load` */
       options: Array<OverviewFilterOptionState>;
+      /** Loads the options of filters that build them from the content */
+      load?: (context: OverviewFilterContext) => OverviewFilterOptions | Promise<OverviewFilterOptions>;
+  }
+  /** A tab of an overview */
+  export interface OverviewTabState {
+      key: string;
+      label: string;
+      filter?: OpenFilter<EntryFields>;
   }
   /** The keys of the options editors picked, by the key of their filter */
   export interface OverviewFilterSelection {
@@ -11787,11 +12390,14 @@ declare module 'alinea/dashboard/atoms/overview' {
       sorts: Array<OverviewSortState>;
       /** The filters editors can apply */
       filters: Array<OverviewFilterState>;
+      /** The tabs above the list, the first one is selected by default */
+      tabs: Array<OverviewTabState>;
       /** The order children are listed in when the editor did not sort */
       sort?: OrderBy | Array<OrderBy>;
       layout?: 'table' | 'cards';
       thumbnail?: OverviewSelection;
       actions: Array<View<OverviewActionProps>>;
+      header?: View<OverviewHeaderProps>;
       /** The names of the types the parent contains */
       types: Array<string>;
   }
@@ -11824,6 +12430,10 @@ declare module 'alinea/dashboard/atoms/overview' {
   export function resolveOverview(config: Config, parent: OverviewParent, options?: OverviewResolveOptions): OverviewState;
   /** Resolves an overview for a list of entries of the given types */
   export function resolveOverviewOptions(config: Config, overview: OverviewOptions | undefined, types: Array<string>, sort: OrderBy | Array<OrderBy> | undefined, options?: OverviewResolveOptions): OverviewState;
+  /** Whether an overview has filters whose options load from the content */
+  export function hasFilterLoaders(overview: OverviewState): boolean;
+  /** Loads the options of the filters that build them from the content */
+  export function loadFilterOptions(overview: OverviewState, context: OverviewFilterContext): Promise<OverviewState>;
   /** The projection a column selects for entries of a type */
   export function columnProjection(select: OverviewSelection | undefined, typeName: string): Projection | undefined;
   /**
@@ -11851,10 +12461,16 @@ declare module 'alinea/dashboard/atoms/overview' {
    */
   export function pickedFilters(overview: OverviewState, selection: OverviewFilterSelection): OverviewFilterSelection;
   /**
-   * The condition of the picked filters: entries match every filter, and any
-   * of the options picked of a filter. Undefined when nothing is picked.
+   * The tab the editor picked, or the first tab when it is unknown. Undefined
+   * when the overview has no tabs.
+   */
+  export function pickedTab(overview: OverviewState, tab: string | undefined): OverviewTabState | undefined;
+  /**
+   * The condition of the selected tab and the picked filters: entries match
+   * the tab, every filter, and any of the options picked of a filter.
+   * Undefined when nothing applies.
    */
-  export function overviewFilter(overview: OverviewState, selection: OverviewFilterSelection): OpenFilter<EntryFields> | undefined;
+  export function overviewFilter(overview: OverviewState, selection: OverviewFilterSelection, tab?: string): OpenFilter<EntryFields> | undefined;
   /** The rows an overview renders, as loaded by the explorer or an EntryTable */
   export interface OverviewRow {
       id: string;
@@ -12358,7 +12974,7 @@ declare module 'alinea/dashboard/atoms/utils' {
 
 declare module 'alinea/dashboard/boot/ActivityEvent' {
 
-  export type ActivityType = 'mutation' | 'upload';
+  export type ActivityType = 'mutation' | 'upload' | 'sync';
   export type ActivityStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'blocked' | 'discarded' | 'cancelled';
   export interface Activity {
       id: string;
@@ -12459,6 +13075,12 @@ declare module 'alinea/dashboard/boot/DashboardWorker' {
       constructor(source?: Source);
       get db(): EntryStore | Promise<EntryStore>;
       sync(): Promise<string>;
+      /**
+       * Resolve once the dashboard can show content. Stored content shows right
+       * away and catches up with the remote as an activity; an empty store, or
+       * one whose cached content failed, waits for its first sync.
+       */
+      ready(): Promise<void>;
       sha(): Promise<string>;
       queue(id: string, mutations: Array<Mutation>): Promise<string>;
       retryActivity(): Promise<void>;
@@ -12478,6 +13100,18 @@ declare module 'alinea/dashboard/boot/LoadWorker' {
   
 }
 
+declare module 'alinea/dashboard/boot/SyncEvent' {
+
+  import type { SyncProgress } from 'alinea/core/db/LocalStore';
+  /** Progress of a sync from the remote, without progress once it finished. */
+  export class SyncEvent extends Event {
+      progress?: SyncProgress | undefined;
+      static readonly type = "sync";
+      constructor(progress?: SyncProgress | undefined);
+  }
+  
+}
+
 declare module 'alinea/dashboard/boot/WorkerDB' {
 
   import type { Config } from 'alinea/core/Config';
@@ -12498,6 +13132,7 @@ declare module 'alinea/dashboard/boot/WorkerDB' {
           sha: string;
       }>;
       resolve<Query extends GraphQuery>(query: Query): Promise<AnyQueryResult<Query>>;
+      ready(): Promise<void>;
       sync(): Promise<string>;
       get sha(): Promise<string>;
       referencesTo(query: EntryReferenceQuery): Promise<EntryReferenceResult>;
@@ -12511,7 +13146,7 @@ declare module 'alinea/dashboard/boot/WorkerDB' {
 
 declare module 'alinea/dashboard/cms/EntryTable' {
 
-  import type { EntryFields } from 'alinea/core/EntryFields';
+  import type { EntryFilterFields } from 'alinea/core/EntryFields';
   import type { OpenFilter } from 'alinea/core/Filter';
   import type { OrderBy } from 'alinea/core/OrderBy';
   import type { OverviewColumn, OverviewOptions } from 'alinea/core/Overview';
@@ -12524,9 +13159,10 @@ declare module 'alinea/dashboard/cms/EntryTable' {
       type?: Type | Array<Type>;
       /**
        * Only list entries matching this filter, like the `filter` of a query,
-       * eg. `{brand: {has: {_entry: entryId}}}`
+       * eg. `{brand: {has: {_entry: entryId}}}` or
+       * `{_referenced: Query.referencedBy({type: Product})}`
        */
-      filter?: OpenFilter<EntryFields>;
+      filter?: OpenFilter<EntryFilterFields>;
       /** Only list entries of this workspace */
       workspace?: string;
       /** Only list entries of this root */
@@ -12601,13 +13237,15 @@ declare module 'alinea/dashboard/cms/hooks' {
    * The hooks of custom field and dashboard views, exported from `alinea/cms`.
    * Their types do not expose the internal state of the dashboard.
    */
+  import type { DashboardEntry } from 'alinea/core/DashboardEntry';
   import type { WriteableGraph } from 'alinea/core/db/WriteableGraph';
-  import type { Entry as EntryRecord } from 'alinea/core/Entry';
+  import type { Entry } from 'alinea/core/Entry';
   import type { Field } from 'alinea/core/Field';
   import type { PreviewMetadata } from 'alinea/core/Preview';
   import type { Policy } from 'alinea/core/Role';
   import type { User } from 'alinea/core/User';
   import { type Dispatch, type SetStateAction } from 'react';
+  import type { DashboardLocation } from 'alinea/dashboard/Href';
   /**
    * Returns the permissions of the signed-in user. Check access with
    * `policy.get({workspace, root, id, ...})`, which returns flags such as
@@ -12631,8 +13269,24 @@ declare module 'alinea/dashboard/cms/hooks' {
   /**
    * Returns the stored value of a field in the entry, list row or object being
    * edited. Use it in a view that only reads the value.
+   *
+   * The field-based hooks (`useFieldValue`, `useField`, `useFieldSetter`, ...)
+   * also read the fields around a custom field: pass a field of the same row,
+   * of a parent row or of the entry, and it resolves in the nearest scope that
+   * holds it. Import the type from your schema or pass the field through the
+   * options of your field.
+   *
+   * A view shared by types that each define their own field can pass its key
+   * instead, which reads the field of the same row, untyped.
+   *
+   * @example
+   * // In the view of a field inside a list row of `BlogPost`
+   * const title = useFieldValue(BlogPost.title) // a field of the entry
+   * const price = useFieldValue(options.price) // a field passed as option
+   * const path = useFieldValue('path') // the path field of this type
    */
   export function useFieldValue<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>): StoredValue;
+  export function useFieldValue(key: string): unknown;
   /**
    * Returns the stored value of a field and a setter, like `useState`. The
    * setter also accepts an updater function that receives the current value.
@@ -12665,40 +13319,38 @@ declare module 'alinea/dashboard/cms/hooks' {
   /**
    * Returns the stored value of another field in the same entry, list row or
    * object, by its key.
+   *
+   * @deprecated Use `useFieldValue`: pass the field, which is typed and also
+   * reads fields of a parent row or the entry (`useFieldValue(BlogPost.title)`),
+   * or its key (`useFieldValue('title')`).
    */
   export function useSiblingFieldValue(key: string): unknown;
   /**
-   * Returns the selected entry version as a plain Entry object.
+   * Returns the entry being edited, in the selected locale and version.
+   * `entry.data` holds the field values as saved: use `useFieldValue(field)`
+   * for the live value while the editor changes it.
    *
-   * Returns null outside an entry scope, or when the current entry cannot be
-   * resolved. The returned value follows locale/status selection and does not
-   * expose internal atoms.
+   * Returns null outside an entry, eg. in a root view.
    */
-  export function useEntry(): EntryRecord<Record<string, unknown>> | null;
+  export function useEntry(): DashboardEntry | null;
+  /** @internal */
+  export function dashboardEntry(entry: Entry): DashboardEntry;
   /**
    * Returns the current locale of the dashboard: the locale of the entry being
    * edited, or the selected locale of the current root. `null` for content
    * without translations or outside the dashboard layout.
    */
   export function useLocale(): string | null;
-  /** A place in the dashboard to navigate to */
-  export interface DashboardLocation {
-      /** Name of the workspace */
-      workspace: string;
-      /** Name of the root */
-      root: string;
-      /** Id of the entry to open, leave out to open the root */
-      entryId?: string;
-      /** Locale to open, for roots with translations */
-      locale?: string | null;
-  }
   /**
    * Returns a function that navigates the dashboard to an entry or root. The
    * user is asked to confirm first when the current entry has unsaved changes.
+   * An entry can be opened by its id alone, its workspace and root are looked
+   * up.
    *
    * @example
    * const navigate = useNavigate()
-   * navigate({workspace: entry.workspace, root: entry.root, entryId: entry.id})
+   * navigate({entryId: post.id, locale: 'en'})
+   * navigate({workspace: 'main', root: 'pages'})
    */
   export function useNavigate(): (location: DashboardLocation) => void;
   
@@ -12732,8 +13384,9 @@ declare module 'alinea/dashboard/cms/ViewProps' {
       section: Section;
   }
   /**
-   * Props of the component a type points to with `view`. It replaces the
-   * default entry editor for entries of that type.
+   * Props of the component a type points to with `view`. It replaces the form
+   * of entries of that type below the entry header, the field hooks edit the
+   * fields of the entry.
    */
   export interface TypeViewProps {
       /** The type of the entry being shown */
@@ -12803,11 +13456,12 @@ declare module 'alinea/dashboard/contexts' {
    */
   export function useEditor(): EditorModel;
   /**
-   * Returns the editor metadata for a field in the active editor scope.
+   * Returns the editor metadata for a field in the active editor scope, or in
+   * the scope of a parent row or the entry when the field belongs there.
    */
   export function useFieldInfo(field: Field): import("alinea/dashboard/atoms/editor").EditorField;
   /**
-   * Returns the reactive node backing a field in the active editor.
+   * Returns the reactive node backing a field in the editor it belongs to.
    */
   export function useFieldNode<Value>(field: Field): ReactiveNode<Value>;
   
@@ -13012,13 +13666,13 @@ declare module 'alinea/dashboard/hook/UseEntryEditor' {
   import type { EntryStatus } from 'alinea/core/Entry';
   export interface EntryEditorVersionData {
       path: string;
-      status: EntryStatus;
   }
   export interface EntryEditorVersion {
       data: EntryEditorVersionData;
       id: string;
       locale: string | null;
       path: string;
+      status: EntryStatus;
       title: string;
       type: string;
   }
@@ -13198,6 +13852,48 @@ declare module 'alinea/dashboard/hooks' {
   
 }
 
+declare module 'alinea/dashboard/Href' {
+
+  import type { EntryDefaultView } from 'alinea/core/Type';
+  /** A place in the dashboard to navigate to */
+  export interface DashboardLocation {
+      /** Name of the workspace, leave out with `root` to open an entry by id */
+      workspace?: string;
+      /** Name of the root, leave out with `workspace` to open an entry by id */
+      root?: string;
+      /** Id of the entry to open, leave out to open the root */
+      entryId?: string;
+      /** Locale to open, for roots with translations */
+      locale?: string | null;
+      /**
+       * Open the entry's form (`edit`) or the list of its children (`overview`),
+       * for entries with both
+       */
+      view?: EntryDefaultView;
+  }
+  /** @internal */
+  export const nav: {
+      splash(): string;
+      users(): string;
+      /** The editor of the entry at `url`, as linked from a page of the site */
+      edit(url: string, workspace?: string, root?: string): string;
+      /** The editor of an entry by id, its workspace and root are looked up */
+      link(entryId: string, locale?: string | null, view?: EntryDefaultView): string;
+      entry(workspace?: string, root?: string, entryId?: string, locale?: string | null, view?: EntryDefaultView, sort?: string, tab?: string): string;
+  };
+  /**
+   * The href of a place in the dashboard, relative to the dashboard's page. An
+   * entry can be linked by its id alone, its workspace and root are looked up
+   * when the link opens. Outside the dashboard, prefix the dashboard's url.
+   *
+   * @example
+   * <a href={href({entryId: post.id})}>{post.title}</a>
+   * const url = `${baseUrl}/admin${href({entryId: post.id})}`
+   */
+  export function href(location: DashboardLocation): string;
+  
+}
+
 declare module 'alinea/dashboard/icons' {
 
   import type { SVGProps } from 'react';
@@ -13383,6 +14079,7 @@ declare module 'alinea/dashboard/icons' {
   export function IcRoundRotateRight(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
   export function IcRoundCrop(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
   export function IcRoundDriveFileMove(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
+  export function IcRoundDownload(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
   
 }
 
@@ -13780,9 +14477,11 @@ declare module 'alinea/database/entry/EntryTable' {
   /** Metadata fields whose queries order by their stored value. */
   export const orderedMetadata: Set<string>;
   /**
-   * Index the stored value of every ordered field in the config, per type, and
-   * of the ordered metadata. Field names are identifiers, so the dotted metadata
-   * names cannot collide with them.
+   * Index the stored value of every ordered field in the config, and of the
+   * ordered metadata. A field is indexed per type that has it, over the rows of
+   * that type only: queries of one type find the index, and the rows of other
+   * types don't take up space in it. The metadata is indexed over every row.
+   * Index names are `type:field` and `metadata.name`, which can't collide.
    */
   export function syncFieldIndexes(db: Database, config: Config): Promise<void>;
   /** An Entry plus the physical-version and local-index fields. */
@@ -13928,7 +14627,16 @@ declare module 'alinea/database/EntryDatabase' {
       getSourceFileStats(): Promise<Map<string, FileStat>>;
       /** Replace the recorded file stats after syncing from a filesystem source. */
       setSourceFileStats(stats: ReadonlyMap<string, FileStat>): Promise<void>;
-      compact(): Promise<void>;
+      /**
+       * Optimize the database and rewrite it when it has pages to reclaim, or
+       * always with `rewrite`. A file that synced many changes keeps the pages of
+       * its tables scattered over it, without any to reclaim: readers that read
+       * ahead, such as the dashboard reading a stored copy, then read it page by
+       * page. Rewriting lays every table out in order.
+       */
+      compact(options?: {
+          rewrite?: boolean;
+      }): Promise<void>;
   }
   
 }
@@ -14086,8 +14794,11 @@ declare module 'alinea/database/LocalDB' {
 
 declare module 'alinea/database/query/Condition' {
 
+  import { type RelationCondition } from 'alinea/core/Filter';
   import { type HasSql, type Sql } from 'rado';
   type FieldSql = (name: string) => HasSql;
+  /** Whether a query of entries related to a field finds an entry */
+  type RelationSql = (name: string, query: RelationCondition) => Sql<boolean>;
   export function jsonField(target: HasSql, segments: Array<string>): HasSql<unknown>;
   /**
    * Match a column against a JSON array parameter, so one prepared statement
@@ -14096,7 +14807,7 @@ declare module 'alinea/database/query/Condition' {
   export function inJson(column: HasSql, values: HasSql<string>): Sql<boolean>;
   /** Compile a condition; `depth` names the array items it iterates. */
   export function compileCondition(field: HasSql, condition: unknown, depth?: number): Sql<boolean>;
-  export function compileFilter(filter: unknown, field: FieldSql): Sql<boolean>;
+  export function compileFilter(filter: unknown, field: FieldSql, relation?: RelationSql): Sql<boolean>;
   export function arrayIncludes(field: HasSql, predicate: (item: HasSql) => Sql<boolean>, depth?: number): Sql<boolean>;
   export {};
   
@@ -14169,7 +14880,7 @@ declare module 'alinea/database/query/Relation' {
 
   import type { EdgeQuery } from 'alinea/core/Graph';
   import { type Sql } from 'rado';
-  import type { EntryIndexTarget } from 'alinea/database/entry/EntryTable';
+  import { type EntryIndexTarget } from 'alinea/database/entry/EntryTable';
   /** Expand the stored references as SQL rows, retaining list order and duplicates. */
   export function linkRelation(source: EntryIndexTarget, field: string, multiple: boolean): {
       target: Sql<unknown>;
@@ -14178,6 +14889,18 @@ declare module 'alinea/database/query/Relation' {
   };
   /** Restrict related identities in SQL before the query's own filters/paging. */
   export function relationCondition(entry: EntryIndexTarget, query: EdgeQuery, source: EntryIndexTarget): Sql<boolean>;
+  /** A link field the referencing entries link through */
+  export interface ReferenceField {
+      /** Where the field is stored in the entry data */
+      path: Array<string>;
+      multiple: boolean;
+  }
+  /**
+   * Entries that link to the source: the reference index finds them, a link
+   * field narrows them down to the ones linking through it. They share the
+   * locale of the source, unless either has none.
+   */
+  export function referencedByCondition(entry: EntryIndexTarget, source: EntryIndexTarget, field?: ReferenceField, sameLocale?: boolean): Sql<boolean>;
   
 }
 
@@ -14217,7 +14940,13 @@ declare module 'alinea/database/query/Search' {
   export function createSearch(db: Database): Promise<void>;
   /** The searchable text of an entry row, read from its search row. */
   export function searchableText(entry: EntryIndexTarget): Sql<string>;
-  export function searchTokens(input: string | Array<string> | undefined): RegExpMatchArray | [] | undefined;
+  /**
+   * The words of a search, each with the tokens the index splits it in: the
+   * index splits `multi-modal` in `multi` and `modal`.
+   */
+  export function searchWords(input: string | Array<string> | undefined): Array<Array<string>> | undefined;
+  /** The tokens of a search, and the joined spelling of split words. */
+  export function searchTokens(input: string | Array<string> | undefined): string[] | undefined;
   export interface SearchQueryOptions {
       /** Indexed spellings a token may also match, besides its prefix. */
       alternatives?(token: string): ReadonlyArray<string>;
@@ -14273,6 +15002,7 @@ declare module 'alinea/database/sync/EntryParser' {
 declare module 'alinea/database/sync/EntrySyncer' {
 
   import type { Config } from 'alinea/core/Config';
+  import type { SyncProgress } from 'alinea/core/db/LocalStore';
   import type { RemoteSource } from 'alinea/core/source/Source';
   import { ReadonlyTree } from 'alinea/core/source/Tree';
   import type { Database } from 'rado';
@@ -14286,6 +15016,7 @@ declare module 'alinea/database/sync/EntrySyncer' {
        * reopened and synced from it. Defaults to true.
        */
       recordsTree?: boolean;
+      onProgress?(progress: SyncProgress): void;
   }
   /** Prepared, serialized source synchronization for one database connection. */
   export class EntrySyncer {
@@ -14303,6 +15034,7 @@ declare module 'alinea/database/sync/EntrySyncer' {
 declare module 'alinea/database/sync/Ingest' {
 
   import type { Config } from 'alinea/core/Config';
+  import type { SyncProgress } from 'alinea/core/db/LocalStore';
   import type { RemoteSource } from 'alinea/core/source/Source';
   import { ReadonlyTree } from 'alinea/core/source/Tree';
   import { type SyncQueries } from 'alinea/database/sync/SyncQueries';
@@ -14322,7 +15054,7 @@ declare module 'alinea/database/sync/Ingest' {
   /** Whether a directory hash stands for a directory with files. */
   export function hasChildren(childrenSha: string | null): boolean;
   /** Write the files that differ between two source trees to the entry table. */
-  export function mergeTrees(config: Config, source: RemoteSource, previousTree: ReadonlyTree, tree: ReadonlyTree, queries: SyncQueries): Promise<SyncChanges>;
+  export function mergeTrees(config: Config, source: RemoteSource, previousTree: ReadonlyTree, tree: ReadonlyTree, queries: SyncQueries, onProgress?: (progress: SyncProgress) => void): Promise<SyncChanges>;
   
 }
 
@@ -14851,17 +15583,16 @@ declare module 'alinea/field/link/EntryLink' {
       const href: import("alinea/core/Expr").Expr<string>;
       const path: import("alinea/core/Expr").Expr<string>;
   }
-  interface EntryOptions<Fields> extends LinkFieldOptions<EntryReference & InferStoredValue<Fields>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
+  export interface EntryOptions<Fields> extends LinkFieldOptions<EntryReference & InferStoredValue<Fields>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
   }
   export function entry<Fields = undefined>(label: Label, options?: WithoutLabel<EntryOptions<Fields>>): import("alinea/field/link/LinkField").LinkField<EntryReference & InferStoredValue<Fields>, EntryLink<LinkFields<{ [K in keyof Fields as Fields[K] extends import("alinea/core/Expr").Expr<any> ? K : never]: Fields[K] extends import("alinea/core/Expr").Expr<infer T_1> ? T_1 : never; } extends infer T ? { [K in keyof T]: T[K]; } : never>>>;
+  export interface EntriesOptions<Fields> extends LinkFieldOptions<Array<EntryReference & ListRow & InferStoredValue<Fields>>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
+  }
   export namespace entry {
       type EntryRow<Fields> = EntryLink<LinkFields<Type.Infer<Fields>>> & ListRow;
-      interface EntryOptions<Fields> extends LinkFieldOptions<Array<EntryReference & ListRow & InferStoredValue<Fields>>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
-      }
-      export function multiple<Fields = undefined>(label: Label, options?: WithoutLabel<EntryOptions<Fields>>): import("alinea/field/link/LinkField").LinksField<EntryReference & ListRow & InferStoredValue<Fields>, EntryRow<Fields>>;
+      export function multiple<Fields = undefined>(label: Label, options?: WithoutLabel<EntriesOptions<Fields>>): import("alinea/field/link/LinkField").LinksField<EntryReference & ListRow & InferStoredValue<Fields>, EntryRow<Fields>>;
       export {};
   }
-  export {};
   
 }
 
@@ -14895,9 +15626,9 @@ declare module 'alinea/field/link/FileLink' {
   export interface FileOptions<Fields> extends LinkFieldOptions<EntryReference & InferStoredValue<Fields>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
   }
   export function file<Fields = undefined>(label: Label, options?: WithoutLabel<FileOptions<Fields>>): import("alinea/field/link/LinkField").LinkField<EntryReference & InferStoredValue<Fields>, FileLink<LinkFields<{ [K in keyof Fields as Fields[K] extends import("alinea/core/Expr").Expr<any> ? K : never]: Fields[K] extends import("alinea/core/Expr").Expr<infer T_1> ? T_1 : never; } extends infer T ? { [K in keyof T]: T[K]; } : never>>>;
+  export interface FilesOptions<Fields> extends LinkFieldOptions<Array<EntryReference & ListRow & InferStoredValue<Fields>>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
+  }
   export namespace file {
-      interface FilesOptions<Fields> extends LinkFieldOptions<Array<EntryReference & ListRow & InferStoredValue<Fields>>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
-      }
       function multiple<Fields = undefined>(label: Label, options?: WithoutLabel<FilesOptions<Fields>>): import("alinea/field/link/LinkField").LinksField<EntryReference & ListRow & InferStoredValue<Fields>, FileLink<LinkFields<{ [K in keyof Fields as Fields[K] extends import("alinea/core/Expr").Expr<any> ? K : never]: Fields[K] extends import("alinea/core/Expr").Expr<infer T_1> ? T_1 : never; } extends infer T ? { [K in keyof T]: T[K]; } : never>>>;
   }
   
@@ -14918,8 +15649,6 @@ declare module 'alinea/field/link/ImageLink' {
       alt?: string;
       /** Public url of the image file, versioned by its hash */
       src: string;
-      /** Same as src */
-      url: string;
       extension: string;
       size: number;
       hash: string;
@@ -14937,7 +15666,6 @@ declare module 'alinea/field/link/ImageLink' {
       const title: import("alinea/core/Expr").Expr<string>;
       const alt: import("alinea/core/media/MediaAltField").MediaAltField;
       const src: import("alinea/core/Expr").Expr<string>;
-      const url: import("alinea/core/Expr").Expr<string>;
       const extension: import("alinea/field/hidden").HiddenField<string>;
       const size: import("alinea/field/hidden").HiddenField<number>;
       const hash: import("alinea/field/hidden").HiddenField<string>;
@@ -14957,9 +15685,9 @@ declare module 'alinea/field/link/ImageLink' {
   export function image<Fields = undefined>(label: Label, options?: WithoutLabel<ImageOptions<Fields>>): ImageField<Fields>;
   export interface ImagesField<Fields = undefined> extends LinksField<EntryReference & ListRow & InferStoredValue<Fields>, ImageLink<LinkFields<Type.Infer<Fields>>>> {
   }
+  export interface ImagesOptions<Fields> extends LinkFieldOptions<Array<EntryReference & ListRow & InferStoredValue<Fields>>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
+  }
   export namespace image {
-      interface ImagesOptions<Fields> extends LinkFieldOptions<Array<EntryReference & ListRow & InferStoredValue<Fields>>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
-      }
       function multiple<Fields = undefined>(label: Label, options?: WithoutLabel<ImagesOptions<Fields>>): ImagesField<Fields>;
   }
   
@@ -16079,6 +16807,8 @@ declare module 'alinea/field/richtext/Toolbar' {
   export interface ToolbarMenu {
       icon?: (ctx: RichTextToolbarContext) => IconType;
       label?: ReactNode | ((ctx: RichTextToolbarContext) => ReactNode);
+      /** Marks the menu trigger, eg. while a value other than the default applies */
+      active?: (ctx: RichTextToolbarContext) => boolean;
       items: ToolbarConfig | ((ctx: RichTextToolbarContext) => ToolbarConfig);
   }
   export interface ToolbarGroup {
@@ -16103,6 +16833,7 @@ declare module 'alinea/field/richtext/Toolbar' {
   export const headings: {
       icon: () => import("react").JSX.Element;
       label({ editor }: RichTextToolbarContext): string;
+      active: ({ editor }: RichTextToolbarContext) => boolean;
       items: {
           styles: {
               group: {
@@ -16112,22 +16843,27 @@ declare module 'alinea/field/richtext/Toolbar' {
                   };
                   h1: {
                       label: () => import("react").JSX.Element;
+                      active: ({ editor }: RichTextToolbarContext) => boolean;
                       onSelect: ({ exec }: RichTextToolbarContext) => boolean;
                   };
                   h2: {
                       label: () => import("react").JSX.Element;
+                      active: ({ editor }: RichTextToolbarContext) => boolean;
                       onSelect: ({ exec }: RichTextToolbarContext) => boolean;
                   };
                   h3: {
                       label: () => import("react").JSX.Element;
+                      active: ({ editor }: RichTextToolbarContext) => boolean;
                       onSelect: ({ exec }: RichTextToolbarContext) => boolean;
                   };
                   h4: {
                       label: () => import("react").JSX.Element;
+                      active: ({ editor }: RichTextToolbarContext) => boolean;
                       onSelect: ({ exec }: RichTextToolbarContext) => boolean;
                   };
                   h5: {
                       label: () => import("react").JSX.Element;
+                      active: ({ editor }: RichTextToolbarContext) => boolean;
                       onSelect: ({ exec }: RichTextToolbarContext) => boolean;
                   };
               };
@@ -16192,11 +16928,11 @@ declare module 'alinea/field/richtext/Toolbar' {
   };
   export const alignment: {
       icon({ editor }: RichTextToolbarContext): import("react").JSX.Element;
+      active: ({ editor }: RichTextToolbarContext) => boolean;
       items: {
           left: {
               icon: () => import("react").JSX.Element;
               label: string;
-              active: ({ editor }: RichTextToolbarContext) => boolean;
               onSelect: ({ exec }: RichTextToolbarContext) => boolean;
           };
           center: {
@@ -16524,6 +17260,7 @@ declare module 'alinea' {
   export * as Edit from 'alinea/edit';
   export * as Field from 'alinea/field';
   export * as Query from 'alinea/query';
+  export { href } from 'alinea/dashboard/Href';
   export type * from 'alinea/types';
   
 }
@@ -16534,7 +17271,9 @@ declare module 'alinea/next' {
   export type { NextHandlerOptions } from 'alinea/adapter/next/handler';
   export { createCMS, createHandler } from 'alinea/adapter/next/node';
   export { withAlinea } from 'alinea/adapter/next/with-alinea';
+  export type { RemovedEntry } from 'alinea/backend/CommitEntries';
   export type { AfterCommitContext, BeforeCommitContext } from 'alinea/backend/Handler';
+  export type { DashboardEntry } from 'alinea/core/DashboardEntry';
   
 }
 
@@ -16542,7 +17281,9 @@ declare module 'alinea/next.edge' {
 
   export { createCMS, type SyncStatus } from 'alinea/adapter/next/cms';
   export { createHandler, type NextHandlerOptions } from 'alinea/adapter/next/handler';
+  export type { RemovedEntry } from 'alinea/backend/CommitEntries';
   export type { AfterCommitContext, BeforeCommitContext } from 'alinea/backend/Handler';
+  export type { DashboardEntry } from 'alinea/core/DashboardEntry';
   
 }
 
@@ -16555,7 +17296,7 @@ declare module 'alinea/picker/entry' {
 declare module 'alinea/picker/entry/EntryPicker' {
 
   import type { EntryFields } from 'alinea/core/EntryFields';
-  import type { OpenFilter } from 'alinea/core/Filter';
+  import { type OpenFilter } from 'alinea/core/Filter';
   import type { Graph, Projection } from 'alinea/core/Graph';
   import type { Label } from 'alinea/core/Label';
   import type { Picker } from 'alinea/core/Picker';
@@ -16608,6 +17349,8 @@ declare module 'alinea/picker/entry/EntryPicker' {
       fields?: Definition | Type<Definition>;
   }
   export function entryPicker<Ref extends EntryReference, Fields>(options: EntryPickerOptions<Fields>): Picker<Ref, EntryPickerOptions<Fields>>;
+  /** @internal Throws for conditions an entry picker can't check, eg. relation filters */
+  export function assertPickerCondition(condition: OpenFilter<EntryFields>): void;
   export {};
   
 }
@@ -16819,21 +17562,23 @@ declare module 'alinea/preview/widget' {
 
 declare module 'alinea/query' {
 
+  import type { Expr } from 'alinea/core/Expr';
   import type { GraphQuery, IncludeGuard, PickModifiers, QueryModifiers, SelectionGuard, TypeGuard } from 'alinea/core/Graph';
-  export const id: import("alinea/core/Expr").Expr<string>;
-  export const title: import("alinea/core/Expr").Expr<string>;
-  export const type: import("alinea/core/Expr").Expr<string>;
-  export const index: import("alinea/core/Expr").Expr<string>;
-  export const workspace: import("alinea/core/Expr").Expr<string>;
-  export const root: import("alinea/core/Expr").Expr<string>;
-  export const status: import("alinea/core/Expr").Expr<import("alinea/core/Entry").EntryStatus>;
-  export const parentId: import("alinea/core/Expr").Expr<string | null>;
-  export const locale: import("alinea/core/Expr").Expr<string | null>;
-  export const path: import("alinea/core/Expr").Expr<string>;
-  export const url: import("alinea/core/Expr").Expr<string>;
-  export const aliases: import("alinea/core/Expr").Expr<import("alinea/core/Entry").EntryAlias[]>;
-  export const createdAt: import("alinea/core/Expr").Expr<number | null>;
-  export const updatedAt: import("alinea/core/Expr").Expr<number | null>;
+  import type { HasField } from 'alinea/core/Internal';
+  export const id: Expr<string>;
+  export const title: Expr<string>;
+  export const type: Expr<string>;
+  export const index: Expr<string>;
+  export const workspace: Expr<string>;
+  export const root: Expr<string>;
+  export const status: Expr<import("alinea/core/Entry").EntryStatus>;
+  export const parentId: Expr<string | null>;
+  export const locale: Expr<string | null>;
+  export const path: Expr<string>;
+  export const url: Expr<string>;
+  export const aliases: Expr<import("alinea/core/Entry").EntryAlias[]>;
+  export const createdAt: Expr<number | null>;
+  export const updatedAt: Expr<number | null>;
   export { snippet } from 'alinea/core/pages/Snippet';
   /** A relation query, see PickModifiers */
   type RelationQuery<Edge extends string, Selection, Type, Include, Modifiers> = {
@@ -16862,24 +17607,37 @@ declare module 'alinea/query' {
   export function parent<Selection extends SelectionGuard = undefined, Type extends TypeGuard = undefined, Include extends IncludeGuard = undefined, Modifiers extends QueryModifiers = {}>(query: GraphQuery<Selection, Type, Include> & Modifiers): RelationQuery<'parent', Selection, Type, Include, Modifiers>;
   export function next<Selection extends SelectionGuard = undefined, Type extends TypeGuard = undefined, Include extends IncludeGuard = undefined, Modifiers extends QueryModifiers = {}>(query: GraphQuery<Selection, Type, Include> & Modifiers): RelationQuery<'next', Selection, Type, Include, Modifiers>;
   export function previous<Selection extends SelectionGuard = undefined, Type extends TypeGuard = undefined, Include extends IncludeGuard = undefined, Modifiers extends QueryModifiers = {}>(query: GraphQuery<Selection, Type, Include> & Modifiers): RelationQuery<'previous', Selection, Type, Include, Modifiers>;
+  /**
+   * The entries that link to the entry, eg. the products of a brand:
+   * `Query.referencedBy({type: Product})`. Set `field` to only follow one
+   * link field, eg. `{type: Product, field: Product.brand}`.
+   */
+  export function referencedBy<Selection extends SelectionGuard = undefined, Type extends TypeGuard = undefined, Include extends IncludeGuard = undefined, Modifiers extends QueryModifiers = {}>(query: GraphQuery<Selection, Type, Include> & Modifiers & {
+      field?: HasField & Expr;
+  }): RelationQuery<'referencedBy', Selection, Type, Include, Modifiers> & {
+      field?: HasField & Expr;
+  };
   
 }
 
 declare module 'alinea/types' {
 
+  export type { DashboardEntry, EntryActionProps } from 'alinea/core/DashboardEntry';
+  export type { FieldOptions, WithoutLabel } from 'alinea/core/Field';
   export type { Filter } from 'alinea/core/Filter';
-  export type { Graph, GraphQuery } from 'alinea/core/Graph';
+  export type { Graph, GraphQuery, QuerySettings } from 'alinea/core/Graph';
   export type { Infer } from 'alinea/core/Infer';
   export type { ListRow } from 'alinea/core/ListRow';
-  export type { OverviewActionProps, OverviewBuiltins, OverviewCellProps, OverviewColumn, OverviewEntry, OverviewFilter, OverviewFilterOption, OverviewFormatContext, OverviewOptions, OverviewSort, OverviewSortBy, OverviewSortDirection, OverviewSortOption } from 'alinea/core/Overview';
+  export type { OverviewActionProps, OverviewBuiltins, OverviewCellProps, OverviewColumn, OverviewEntry, OverviewFilter, OverviewFilterContext, OverviewFilterOption, OverviewFilterOptions, OverviewFormatContext, OverviewHeaderProps, OverviewOptions, OverviewSort, OverviewSortBy, OverviewSortDirection, OverviewSortOption, OverviewTab } from 'alinea/core/Overview';
   export type { Root } from 'alinea/core/Root';
   export type { Schema } from 'alinea/core/Schema';
   export type { BlockNode, ElementNode, ImageNode, LinkMark, Mark, TextDoc, TextNode } from 'alinea/core/TextDoc';
   export type { EntryUrlMeta, Type } from 'alinea/core/Type';
   export type { Workspace } from 'alinea/core/Workspace';
-  export type { EntryLink } from 'alinea/field/link/EntryLink';
-  export type { FileLink } from 'alinea/field/link/FileLink';
-  export type { ImageLink } from 'alinea/field/link/ImageLink';
+  export type { DashboardLocation } from 'alinea/dashboard/Href';
+  export type { EntriesOptions, EntryLink, EntryOptions } from 'alinea/field/link/EntryLink';
+  export type { FileLink, FileOptions, FilesOptions } from 'alinea/field/link/FileLink';
+  export type { ImageLink, ImageOptions, ImagesOptions } from 'alinea/field/link/ImageLink';
   export type { Link } from 'alinea/field/link/Link';
   export type { UrlLink } from 'alinea/field/link/UrlLink';
   export type { EntryReference } from 'alinea/picker/entry/EntryReference';
@@ -17151,11 +17909,13 @@ declare module 'alinea/ui/Stack' {
       autoWidth?: boolean;
   }
   /**
-   * @deprecated Compatibility component for legacy dashboard extensions.
+   * @deprecated Compatibility component for legacy dashboard extensions, use
+   * `Stack` from `alinea/components`.
    */
   export const VStack: import("react").ForwardRefExoticComponent<StackProps & import("react").RefAttributes<HTMLElement>>;
   /**
-   * @deprecated Compatibility component for legacy dashboard extensions.
+   * @deprecated Compatibility component for legacy dashboard extensions, use
+   * `<Stack direction="row">` from `alinea/components`.
    */
   export const HStack: import("react").ForwardRefExoticComponent<StackProps & import("react").RefAttributes<HTMLElement>>;