alinea 2.0.0-preview.12 → 2.0.0-preview.13

package/dist/bundled.d.ts

@@ -93,6 +93,17 @@ declare module 'alinea/adapter/next/context' {
   
 }
 
+declare module 'alinea/adapter/next/dashboardUrl' {
+
+  import { Config } from 'alinea/core/Config';
+  /**
+   * The dashboard as the site serves it: in development the site proxies the
+   * admin path to the dev server, in production it serves the generated file.
+   */
+  export function dashboardUrl(config: Config, isDev: boolean, handlerUrl: URL | string): string;
+  
+}
+
 declare module 'alinea/adapter/next/devCache' {
 
   /**
@@ -231,15 +242,28 @@ declare module 'alinea/adapter/next/syncCheck' {
       syncWith(source: RemoteSource, options?: SyncOptions): Promise<string>;
   }
   export const CONTENT_SHA_TAG = "alinea-content-sha";
+  /**
+   * How long renders share the latest content sha. Configured through the
+   * config's `syncInterval`, never a query's: all renders share one entry.
+   */
+  export function contentShaWindow(syncInterval?: number): number;
+  /**
+   * Tag a static render with the content sha without looking it up. Renders at
+   * build skip `syncIfStale`, so this is how their pages join the tag that
+   * commits revalidate, and get the same time-based safety net as pages
+   * rendered at runtime.
+   */
+  export function tagContentSha(revalidate?: number): Promise<void>;
   export function revalidateContentSha(): Promise<void>;
   /**
    * Sync the isolate-local db only when it is behind the shared content sha.
    * Returns true when the freshness question is settled here (synced, forced,
    * or explicitly disabled) and the caller can skip its throttled sync.
    * Returns false when the sha could not be determined, so the caller falls
-   * back to its existing throttle behavior.
+   * back to its existing throttle behavior. `shaWindow` is how long renders
+   * share the latest sha, see `contentShaWindow`.
    */
-  export function syncIfStale(db: SyncableDB, client: Client, syncInterval?: number, options?: SyncOptions): Promise<boolean>;
+  export function syncIfStale(db: SyncableDB, client: Client, syncInterval?: number, shaWindow?: number, options?: SyncOptions): Promise<boolean>;
   export {};
   
 }
@@ -296,6 +320,32 @@ declare module 'alinea/backend/api/BasicAuth' {
   
 }
 
+declare module 'alinea/backend/api/BlobStore' {
+
+  import type { CommitApi, SyncApi } from 'alinea/core/Connection';
+  /**
+   * Content blobs kept where every handler instance finds them, such as the
+   * backend database: an instance that is behind reads what another one
+   * fetched or committed, instead of fetching it from the remote again.
+   */
+  export interface BlobStore {
+      /** The stored blobs among `shas`. */
+      readBlobs(shas: ReadonlyArray<string>): Promise<Map<string, Uint8Array>>;
+      /** Keep blobs, found again by their sha. */
+      storeBlobs(blobs: ReadonlyArray<[sha: string, blob: Uint8Array]>): Promise<void>;
+  }
+  export function isBlobStore<T extends object>(value: T): value is T & BlobStore;
+  /**
+   * Answer from the store what it has, and fetch the rest from the remote,
+   * storing it. The store only saves requests: when it fails, the remote
+   * answers instead.
+   */
+  export function storedBlobs(store: BlobStore, getBlobs: SyncApi['getBlobs']): SyncApi['getBlobs'];
+  /** Commit through the remote, and store the committed content. */
+  export function storedWrites(store: BlobStore, write: CommitApi['write']): CommitApi['write'];
+  
+}
+
 declare module 'alinea/backend/api/CreateBackend' {
 
   import type { Config } from 'alinea/core/Config';
@@ -344,10 +394,11 @@ declare module 'alinea/backend/api/DatabaseApi' {
   import { type Draft, type DraftKey } from 'alinea/core/Draft';
   import type { User, UserInput } from 'alinea/core/User';
   import { type Database } from 'rado';
+  import type { BlobStore } from 'alinea/backend/api/BlobStore';
   export interface DatabaseOptions {
       db: Database;
   }
-  export class DatabaseApi implements DraftsApi, UploadsApi, UserApi {
+  export class DatabaseApi implements DraftsApi, UploadsApi, UserApi, BlobStore {
       #private;
       constructor(context: RequestContext, { db }: DatabaseOptions);
       getDraft(draftKey: DraftKey): Promise<Draft | undefined>;
@@ -355,6 +406,8 @@ declare module 'alinea/backend/api/DatabaseApi' {
       prepareUpload(file: string): Promise<UploadResponse>;
       handleUpload(entryId: string, file: Blob): Promise<void>;
       previewUpload(entryId: string): Promise<Response>;
+      readBlobs(shas: ReadonlyArray<string>): Promise<Map<string, Uint8Array>>;
+      storeBlobs(blobs: ReadonlyArray<[sha: string, blob: Uint8Array]>): Promise<void>;
       enrichUser(user: User): Promise<User>;
       listUsers(): Promise<Array<User>>;
       createUser(user: UserInput): Promise<User>;
@@ -1921,6 +1974,7 @@ declare module 'alinea/components' {
   export * from 'alinea/components/Resizable';
   export * from 'alinea/components/SearchField';
   export * from 'alinea/components/Select';
+  export * from 'alinea/components/Sheet';
   export * from 'alinea/components/Sidebar';
   export * from 'alinea/components/SortableList';
   export * from 'alinea/components/Spinner';
@@ -2003,12 +2057,14 @@ declare module 'alinea/components/Badge' {
   export interface BadgeProps extends StyleProps, AriaProps, DataProps {
       icon?: IconType | ReactElement;
       size?: 'default' | 'sm';
+      /** `primary` tints the badge with the accent color, eg. to name a type */
+      color?: 'default' | 'primary';
       /** Colors the badge like the matching entry status */
       status?: ContentStatus;
       title?: string;
       children?: ReactNode;
   }
-  export function Badge({ icon, size, status, className, children, ...props }: BadgeProps): import("react").JSX.Element;
+  export function Badge({ icon, size, color, status, className, children, ...props }: BadgeProps): import("react").JSX.Element;
   
 }
 
@@ -2095,11 +2151,16 @@ declare module 'alinea/components/Button' {
       'aria-current'?: boolean | 'page' | 'step' | 'location' | 'date' | 'time';
       /** Keyboard shortcuts that activate the button, eg. `Meta+K Control+K` */
       'aria-keyshortcuts'?: string;
+      /**
+       * Lets a press on the button start a native drag, eg. of the draggable
+       * element it is in: browsers do not drag from a button otherwise
+       */
+      draggable?: boolean;
       onClick?: (event: MouseEvent<HTMLButtonElement>) => void;
       ref?: Ref<HTMLButtonElement>;
       children?: ReactNode;
   }
-  export function Button({ variant, color, size, active, icon, asChild, disabled, loading, className, children, onClick, 'aria-keyshortcuts': ariaKeyShortcuts, ...props }: ButtonProps): import("react").JSX.Element;
+  export function Button({ variant, color, size, active, icon, asChild, disabled, loading, className, children, onClick, 'aria-keyshortcuts': ariaKeyShortcuts, draggable, ...props }: ButtonProps): import("react").JSX.Element;
   
 }
 
@@ -2373,6 +2434,8 @@ declare module 'alinea/components/ContentCard' {
   import type { IconType, StyleProps } from 'alinea/components/types';
   export interface ContentCardProps extends StyleProps {
       title: ReactNode;
+      /** Shown right after the title, eg. a status icon */
+      suffix?: ReactNode;
       /**
        * `icon` (the default) shows the icon on a neutral background, `media`
        * previews a file: its image on the `color` placeholder, or a file icon
@@ -2394,7 +2457,7 @@ declare module 'alinea/components/ContentCard' {
       details?: ReactNode;
   }
   /** The contents of a ContentGridItem, mirroring the dashboard explorer cards */
-  export function ContentCard({ title, variant, icon, iconColor, image, color, breadcrumbs, description, details, className, style }: ContentCardProps): import("react").JSX.Element;
+  export function ContentCard({ title, suffix, variant, icon, iconColor, image, color, breadcrumbs, description, details, className, style }: ContentCardProps): import("react").JSX.Element;
   export interface ContentCardSkeletonProps extends StyleProps {
   }
   /** A pulsing placeholder card for items that are still loading */
@@ -3045,6 +3108,30 @@ declare module 'alinea/components/internal/Slot' {
   
 }
 
+declare module 'alinea/components/internal/sortableDrag' {
+
+  export interface SortableDragOptions {
+      /** The pointerdown on the item that may start the drag */
+      event: PointerEvent;
+      list: HTMLElement;
+      item: HTMLElement;
+      /** The item elements of the list, in order */
+      items(): Array<HTMLElement>;
+      /**
+       * Moves `item` before or after `target`. Must render the new order before
+       * it returns, so the items swap places without a frame in between.
+       */
+      onDrop(item: HTMLElement, target: HTMLElement, position: 'before' | 'after'): void;
+  }
+  /**
+   * Lets the item follow the pointer once it moves past a small threshold,
+   * while the other items move aside to show where it lands. Drops on release,
+   * Escape cancels.
+   */
+  export function pressSortableItem({ event, list, item, items, onDrop }: SortableDragOptions): void;
+  
+}
+
 declare module 'alinea/components/internal/ToggleButton' {
 
   import type { ReactElement, ReactNode, Ref } from 'react';
@@ -3617,6 +3704,11 @@ declare module 'alinea/components/SearchField' {
       placeholder?: string;
       /** Shows a spinner while results are being loaded */
       loading?: boolean;
+      /**
+       * `inline` drops the box so the field reads as the top row of the results
+       * it searches, like a command palette. The row draws its own border.
+       */
+      variant?: 'default' | 'inline';
       name?: string;
       autoFocus?: boolean;
       onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
@@ -3642,7 +3734,7 @@ declare module 'alinea/components/SearchField' {
    * A text input for search queries with a clear button. The `icon` is shown
    * inside the input, in front of the query.
    */
-  export function SearchField({ label, description, error, required, disabled, readOnly, icon, shared, onValueChange, placeholder, loading, onBlur, onFocus, onKeyDown, role, 'aria-controls': ariaControls, 'aria-activedescendant': ariaActiveDescendant, 'aria-expanded': ariaExpanded, 'aria-haspopup': ariaHasPopup, 'aria-autocomplete': ariaAutocomplete, className, ...props }: SearchFieldProps): import("react").JSX.Element;
+  export function SearchField({ label, description, error, required, disabled, readOnly, icon, shared, onValueChange, placeholder, loading, variant, onBlur, onFocus, onKeyDown, role, 'aria-controls': ariaControls, 'aria-activedescendant': ariaActiveDescendant, 'aria-expanded': ariaExpanded, 'aria-haspopup': ariaHasPopup, 'aria-autocomplete': ariaAutocomplete, className, ...props }: SearchFieldProps): import("react").JSX.Element;
   
 }
 
@@ -3689,6 +3781,61 @@ declare module 'alinea/components/Select' {
   
 }
 
+declare module 'alinea/components/Sheet' {
+
+  import { type MouseEvent, type ReactNode } from 'react';
+  import type { AriaProps, DataProps, StyleProps } from 'alinea/components/types';
+  export interface SheetContentProps extends StyleProps, AriaProps, DataProps {
+      /** Called on Escape while focus is inside the sheet, and by `SheetClose` */
+      onClose?: () => void;
+      /** Accessible label of the back button in the header, defaults to "Back" */
+      backLabel?: string;
+      children: ReactNode;
+  }
+  /**
+   * A non-modal panel that fills its positioned container. Mount it to open
+   * the sheet: focus moves to its first field, and returns to the previously
+   * focused element when it unmounts. Labelled by its `SheetTitle` unless
+   * given an `aria-label`.
+   */
+  export function SheetContent({ onClose, backLabel, className, children, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledby, ...props }: SheetContentProps): import("react").JSX.Element;
+  export interface SheetPartProps extends StyleProps, AriaProps, DataProps {
+      children?: ReactNode;
+  }
+  export interface SheetHeaderProps extends SheetPartProps {
+  }
+  /**
+   * Top bar of the sheet, eg. a badge, the title, a key hint and SheetClose.
+   * Starts with a back button when the sheet has an `onClose`.
+   */
+  export function SheetHeader({ className, children, ...props }: SheetHeaderProps): import("react").JSX.Element;
+  export interface SheetTitleProps extends SheetPartProps {
+  }
+  export function SheetTitle({ className, ...props }: SheetTitleProps): import("react").JSX.Element;
+  export interface SheetBodyProps extends SheetPartProps {
+  }
+  /** Scrolling content of the sheet, holds SheetSection elements */
+  export function SheetBody({ className, ...props }: SheetBodyProps): import("react").JSX.Element;
+  export interface SheetSectionProps extends SheetPartProps {
+      title?: ReactNode;
+  }
+  export function SheetSection({ title, className, children, ...props }: SheetSectionProps): import("react").JSX.Element;
+  export interface SheetFooterProps extends SheetPartProps {
+  }
+  /**
+   * Bottom bar of the sheet, holds small ghost buttons. Destructive buttons
+   * are pushed to the end.
+   */
+  export function SheetFooter({ className, ...props }: SheetFooterProps): import("react").JSX.Element;
+  export interface SheetCloseProps extends StyleProps, DataProps {
+      'aria-label': string;
+      /** Defaults to the `onClose` of the surrounding SheetContent */
+      onClick?: (event: MouseEvent<HTMLButtonElement>) => void;
+  }
+  export function SheetClose({ onClick, ...props }: SheetCloseProps): import("react").JSX.Element;
+  
+}
+
 declare module 'alinea/components/Sidebar' {
 
   import { type ReactNode, type Ref } from 'react';
@@ -3752,49 +3899,59 @@ declare module 'alinea/components/Sidebar' {
 
 declare module 'alinea/components/SortableList' {
 
-  import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+  import { type ComponentPropsWithRef, type ComponentPropsWithoutRef } from 'react';
   import { type ButtonProps } from 'alinea/components/Button';
-  import { type SurfaceProps } from 'alinea/components/Surface';
-  import type { DragMoveEvent, IconType, Key } from 'alinea/components/types';
-  export interface SortableListProps extends SurfaceProps {
+  import type { DragMoveEvent, Key } from 'alinea/components/types';
+  export interface SortableListProps extends ComponentPropsWithoutRef<'div'> {
       /**
-       * Enables reordering: items with an `id` can be dragged by their
-       * `SortableListHandle`, with a pointer or with the keyboard (Enter on the
-       * handle, Tab to an item, Enter to drop). Called with the key of the dragged
-       * item and the item it was dropped before or after.
-       * Items only drop within the list they were dragged from.
+       * Enables reordering: items with an `id` follow the pointer when their
+       * `SortableListItemHeader` is dragged, the other items move aside as it
+       * passes them. With focus in the header, Alt+ArrowUp and Alt+ArrowDown
+       * move an item. Called with the key of the moved item and the item it was
+       * dropped before or after. Update the order synchronously: the dropped item
+       * glides into the place it renders in right after this returns.
        */
       onReorder?: (event: DragMoveEvent) => void;
-      /** Mime type the dragged items carry, defaults to `alinea/sortable-list-item` */
-      dragType?: string;
   }
-  export function SortableList({ className, role, onReorder, dragType, ...props }: SortableListProps): import("react").JSX.Element;
+  export function SortableList({ className, role, onReorder, ...props }: SortableListProps): import("react").JSX.Element;
   export interface SortableListItemProps extends Omit<ComponentPropsWithoutRef<'div'>, 'id'> {
       /**
        * Identifies the item within its list. Items with an id can be dragged when
        * the list has `onReorder`. The id is not rendered as a DOM id.
        */
       id?: Key;
-      /** Rendered under the pointer while dragging, eg. a `SortableListDragPreview` */
-      dragPreview?: ReactNode;
+      /** Highlights the item, eg. while its settings are open next to the list */
+      current?: boolean;
   }
-  export function SortableListItem({ id, dragPreview, ...props }: SortableListItemProps): import("react").JSX.Element;
+  export function SortableListItem({ id, className, current, ...props }: SortableListItemProps): import("react").JSX.Element;
   export interface SortableListItemHeaderProps extends ComponentPropsWithoutRef<'div'> {
   }
-  /** Top bar of an item, holds its handle, title and actions */
-  export function SortableListItemHeader({ className, ...props }: SortableListItemHeaderProps): import("react").JSX.Element;
-  export interface SortableListHandleProps extends ComponentPropsWithoutRef<'span'> {
-  }
   /**
-   * Drags its `SortableListItem` when the list has `onReorder`. Focusable in
-   * that case: press Enter to start a keyboard drag. Place it in the
-   * `SortableListItemHeader`, it shows while the header is hovered or focused.
+   * Top bar of an item, holds its title and actions. Drags the item when the
+   * list has `onReorder`, a press that does not move still clicks.
    */
-  export function SortableListHandle({ className, ...props }: SortableListHandleProps): import("react").JSX.Element;
+  export function SortableListItemHeader({ className, onPointerDownCapture, onKeyDown, onDragStart, ...props }: SortableListItemHeaderProps): import("react").JSX.Element;
   export interface SortableListItemTitleProps extends ComponentPropsWithoutRef<'div'> {
   }
   /** Row of the toggle, badges and description of an item, fills the header */
   export function SortableListItemTitle({ className, ...props }: SortableListItemTitleProps): import("react").JSX.Element;
+  export interface SortableListItemTriggerProps extends Omit<ButtonProps, 'variant' | 'size' | 'icon' | 'asChild'> {
+      /** Ends the button with a "…", defaults to true */
+      more?: boolean;
+  }
+  /**
+   * The badges and description of an item as one button that ends in a "…",
+   * eg. to open the settings of the item. Fills the title up to the actions.
+   */
+  export function SortableListItemTrigger({ className, more, children, ...props }: SortableListItemTriggerProps): import("react").JSX.Element;
+  export interface SortableListItemInsertProps extends Omit<ComponentPropsWithRef<'button'>, 'children'> {
+  }
+  /**
+   * Inserts an item before the one it is placed in: a line with an add button
+   * that shows when the pointer is on the border above the item. Place it first
+   * in the `SortableListItem`.
+   */
+  export function SortableListItemInsert({ className, ...props }: SortableListItemInsertProps): import("react").JSX.Element;
   export interface SortableListItemDescriptionProps extends ComponentPropsWithoutRef<'span'> {
   }
   /** Muted, truncated text next to the badges of an item, eg. its label */
@@ -3803,7 +3960,7 @@ declare module 'alinea/components/SortableList' {
   }
   export function SortableListItemActions({ className, ...props }: SortableListItemActionsProps): import("react").JSX.Element;
   export interface SortableListItemToggleProps extends Omit<ButtonProps, 'variant' | 'children' | 'size'> {
-      /** Whether the item content is shown, rotates the fold icon */
+      /** Whether the item content is shown, picks the unfold icon */
       expanded: boolean;
   }
   /** Folds the content of an item */
@@ -3822,12 +3979,6 @@ declare module 'alinea/components/SortableList' {
   }
   /** A group of settings or actions in the popover of an item */
   export function SortableListItemSettings({ variant, className, ...props }: SortableListItemSettingsProps): import("react").JSX.Element;
-  export interface SortableListDragPreviewProps extends ComponentPropsWithoutRef<'div'> {
-      icon?: IconType;
-      label: ReactNode;
-  }
-  /** Card shown under the pointer while dragging an item */
-  export function SortableListDragPreview({ className, icon, label, ...props }: SortableListDragPreviewProps): import("react").JSX.Element;
   export interface SortableListAddProps extends ComponentPropsWithoutRef<'div'> {
   }
   /** Last row of the list holding the buttons that add items */
@@ -3996,8 +4147,10 @@ declare module 'alinea/components/Table' {
       title: ReactNode;
       /** A small caption above the title, eg. the parent path */
       label?: ReactNode;
+      /** Shown right after the title, eg. a status icon */
+      suffix?: ReactNode;
   }
-  export function TableTitle({ icon, title, label, className, style }: TableTitleProps): import("react").JSX.Element;
+  export function TableTitle({ icon, title, label, suffix, className, style }: TableTitleProps): import("react").JSX.Element;
   
 }
 
@@ -4615,7 +4768,12 @@ declare module 'alinea/core/Config' {
       preview?: Preview;
       /** Every edit will pass through a draft status before being published */
       enableDrafts?: boolean;
-      /** Fallback interval in seconds for polling content updates (freshness is primarily sha-driven) */
+      /**
+       * Fallback interval in seconds for polling content updates (freshness is
+       * primarily sha-driven). In Next.js it also sets how long renders share the
+       * latest content sha, which bounds how soon edits made outside the handler
+       * show up: five minutes when unset.
+       */
       syncInterval?: number;
       /** Maximum file upload size in bytes */
       maxUploadSize?: number;
@@ -4900,24 +5058,6 @@ declare module 'alinea/core/db/EntryUrlConflictError' {
   
 }
 
-declare module 'alinea/core/db/EntryValidationError' {
-
-  import { HttpError } from 'alinea/core/HttpError';
-  import { type FieldValidationError } from 'alinea/core/Validation';
-  export interface EntryValidationErrorInfo {
-      entryId: string;
-      title?: string;
-      errors: Array<FieldValidationError>;
-  }
-  /** A published version would contain fields which fail validation */
-  export class EntryValidationError extends HttpError {
-      info: EntryValidationErrorInfo;
-      name: string;
-      constructor(info: EntryValidationErrorInfo);
-  }
-  
-}
-
 declare module 'alinea/core/db/IndexEvent' {
 
   export class IndexEvent extends Event {
@@ -5282,7 +5422,15 @@ declare module 'alinea/core/Document' {
       path: PathField;
       metadata: MetadataField;
   };
-  export function document<Fields extends FieldsDefinition = {}>(label: string, { fields, ...config }: TypeConfig<Fields> | ContainerTypeConfig<Fields>): Type<Document & Fields>;
+  export type DocumentConfig<Fields, Seo, Details> = (TypeConfig<Fields> | ContainerTypeConfig<Fields>) & {
+      /** 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>;
+  /** Whether `type` was created with `Config.document` */
+  export function isDocument(type: Type): boolean;
   
 }
 
@@ -6754,7 +6902,7 @@ declare module 'alinea/core/Overview' {
   export interface OverviewSort {
       /**
        * A key of `overview.sorts`, of `overview.columns`, or a built-in column:
-       * `title`, `type`, `status`, `updated`, `author`
+       * `title`, `type`, `updated`, `author`
        */
       column: string;
       direction: OverviewSortDirection;
@@ -6864,8 +7012,6 @@ declare module 'alinea/core/Overview' {
   export interface OverviewBuiltins {
       /** The entry type, shown by default when the children have several types */
       type?: boolean;
-      /** The publication status, shown by default when the statuses differ */
-      status?: boolean;
       /** When the entry was last edited, shown by default when recorded */
       updated?: boolean;
       /** Who last edited the entry, shown by default when recorded */
@@ -6876,7 +7022,7 @@ declare module 'alinea/core/Overview' {
       /**
        * Columns shown after the title and the built-in columns, or before the
        * built-in columns with `position: 'start'`. A column keyed `type`,
-       * `status`, `updated` or `author` replaces that built-in column.
+       * `updated` or `author` replaces that built-in column.
        */
       columns?: Record<string, OverviewColumn>;
       /** Show or hide the built-in columns */
@@ -7538,6 +7684,10 @@ declare module 'alinea/core/source/GithubSource' {
   export class GithubSource implements Source {
       #private;
       constructor(options: GithubSourceOptions);
+      /** Request GitHub, counting the request against its budget. */
+      protected githubFetch(input: string, init?: RequestInit): Promise<Response>;
+      /** Run an operation, and log what it spent of GitHub's budgets. */
+      protected spending<T>(operation: string, run: () => Promise<T>): Promise<T>;
       protected get contentLocation(): string;
       getTree(): Promise<ReadonlyTree>;
       shaAt(ref: string): Promise<string>;
@@ -7548,6 +7698,32 @@ declare module 'alinea/core/source/GithubSource' {
   
 }
 
+declare module 'alinea/core/source/GithubUsage' {
+
+  /**
+   * Counts the GitHub requests a source makes against its REST and GraphQL
+   * budgets, and logs what each operation spent and what is left, so the logs
+   * show where a rate limit goes. Answers of 304 are free and not counted.
+   */
+  export class GithubUsage {
+      #private;
+      rest: number;
+      graphql: number;
+      record(response: Response): void;
+      /** The requests counted so far, to log what an operation adds. */
+      count(): {
+          rest: number;
+          graphql: number;
+      };
+      /** Log what `operation` spent since `before`, if anything. */
+      log(operation: string, before: {
+          rest: number;
+          graphql: number;
+      }): void;
+  }
+  
+}
+
 declare module 'alinea/core/source/GitUtils' {
 
   import type { Entry } from 'alinea/core/source/Tree';
@@ -7953,6 +8129,10 @@ declare module 'alinea/core/TextDoc' {
   export interface BlockNode {
       _id: string;
       _type: string;
+      /** A label editors give the block, its anchor follows it by default */
+      _label?: string;
+      /** Lets links point to the block, unique within the entry */
+      _anchor?: string;
   }
   export namespace BlockNode {
       const id = "_id";
@@ -8886,7 +9066,6 @@ declare module 'alinea/core/Validation' {
   /** Validate entry data: required, min, max and validate options */
   export function validateEntry(type: Type, data: unknown, options?: ValidateEntryOptions): Array<FieldValidationError>;
   export function formatFieldPath(path: FieldPath): string;
-  export function formatValidationErrors(errors: ReadonlyArray<FieldValidationError>): string;
   
 }
 
@@ -8986,7 +9165,7 @@ declare module 'alinea/dashboard/App' {
   import type { LocalConnection } from 'alinea/core/Connection';
   import type { WriteableGraph } from 'alinea/core/db/WriteableGraph';
   import type { User } from 'alinea/core/User';
-  import { type ComponentType } from 'react';
+  import { type ComponentType, type ReactNode } from 'react';
   import 'alinea/dashboard/global.css';
   export interface AppProps {
       graph: WriteableGraph;
@@ -8999,7 +9178,7 @@ declare module 'alinea/dashboard/App' {
       /** The user shown as signed in when the dashboard runs locally */
       user?: User;
   }
-  export const appAtom: import("jotai").Atom<readonly [false, import("react").JSX.Element] | readonly [true, import("react").JSX.Element | undefined]>;
+  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;
   
 }
@@ -9073,6 +9252,72 @@ declare module 'alinea/dashboard/app/AuthView' {
   
 }
 
+declare module 'alinea/dashboard/app/BlockSheet' {
+
+  import type { StyleProps } from 'alinea/components';
+  import { type ReactNode } from 'react';
+  const triggerAttribute = "data-block-sheet-trigger";
+  export interface BlockSheetProviderProps {
+      children: ReactNode;
+  }
+  /** Holds the block settings sheet of an entry editor, one open at a time */
+  export function BlockSheetProvider({ children }: BlockSheetProviderProps): import("react").JSX.Element;
+  export interface BlockSheetBoundaryProps {
+      children: ReactNode;
+  }
+  /**
+   * Fields inside have no block settings sheet, eg. in a modal that covers the
+   * sidebar the sheet would open in
+   */
+  export function BlockSheetBoundary({ children }: BlockSheetBoundaryProps): import("react").JSX.Element;
+  export interface BlockSheetSlotProps extends StyleProps {
+  }
+  /** Where the open sheet renders, covers its positioned container */
+  export function BlockSheetSlot({ className, style }: BlockSheetSlotProps): import("react").JSX.Element;
+  export interface BlockSheetTriggerProps {
+      [triggerAttribute]: string;
+  }
+  export interface BlockSheetState {
+      /** False outside an entry editor, where there is no sidebar to cover */
+      available: boolean;
+      open: boolean;
+      /**
+       * Spread on the button that toggles the sheet, so moving focus to it
+       * doesn't close the sheet before the toggle
+       */
+      triggerProps: BlockSheetTriggerProps;
+      setOpen(open: boolean): void;
+      toggle(): void;
+  }
+  /** Open state of the sheet of block `id`, closed outside an entry editor */
+  export function useBlockSheet(id: string): BlockSheetState;
+  /** Whether any block sheet is open or still animating out */
+  export function useBlockSheetOpen(): boolean;
+  export interface BlockSheetProps {
+      id: string;
+      children: ReactNode;
+  }
+  /**
+   * Renders the sheet of block `id` in the slot while it is open. A portal
+   * keeps the sheet owned by its block, so its fields keep the block's node,
+   * editor context, local state and callbacks.
+   */
+  export function BlockSheet({ id, children }: BlockSheetProps): import("react").ReactPortal | null;
+  export {};
+  
+}
+
+declare module 'alinea/dashboard/app/BlockSheetStoryFrame' {
+
+  import type { ReactNode } from 'react';
+  export interface BlockSheetStoryFrameProps {
+      children: ReactNode;
+  }
+  /** Shows field stories next to a panel that hosts their block sheets */
+  export function BlockSheetStoryFrame({ children }: BlockSheetStoryFrameProps): import("react").JSX.Element;
+  
+}
+
 declare module 'alinea/dashboard/app/CompactField' {
 
   import { Field } from 'alinea/core/Field';
@@ -9172,22 +9417,6 @@ declare module 'alinea/dashboard/app/DashboardMeta' {
   
 }
 
-declare module 'alinea/dashboard/app/DeleteDialog' {
-
-  import type { DeletePlan } from 'alinea/dashboard/atoms/delete';
-  export interface DeleteDialogProps {
-      /** What to delete, loaded before it opens, closed when undefined */
-      plan: DeletePlan | undefined;
-      onClose(): void;
-      onConfirm(plan: DeletePlan): Promise<void>;
-      /** Archives the entries instead, offered when all of them can be */
-      onArchive?(plan: DeletePlan): Promise<void>;
-  }
-  /** Confirms deleting entries, warning about the links that will break */
-  export function DeleteDialog({ plan, onClose, onConfirm, onArchive }: DeleteDialogProps): import("react").JSX.Element;
-  
-}
-
 declare module 'alinea/dashboard/app/editor/FileEditor' {
 
   export interface FileEditorProps {
@@ -9430,6 +9659,34 @@ declare module 'alinea/dashboard/app/EntrySidebarToggle' {
   
 }
 
+declare module 'alinea/dashboard/app/EntryStatusIcon' {
+
+  import { type IconType } from 'alinea/components';
+  import type { EntryStatus } from 'alinea/core/Entry';
+  export interface EntryStatusDisplay {
+      icon: IconType;
+      label: string;
+      status: 'draft' | 'unpublished' | 'archived' | 'untranslated';
+  }
+  /** A listed version of an entry, its draft when it has one */
+  export interface ListedEntry {
+      status?: EntryStatus;
+      /** The version is the main one, a draft then was never published */
+      main?: boolean;
+      locale: string | null;
+  }
+  /**
+   * How a listed entry differs from a published one, undefined when it does
+   * not. With a locale, entries of another locale are untranslated.
+   */
+  export function entryStatus(entry: ListedEntry, locale?: string | null): EntryStatusDisplay | undefined;
+  export interface EntryStatusIconProps {
+      status: EntryStatusDisplay;
+  }
+  export function EntryStatusIcon({ status }: EntryStatusIconProps): import("react").JSX.Element;
+  
+}
+
 declare module 'alinea/dashboard/app/EntryTranslationBanner' {
 
   export interface EntryTranslationBannerProps {
@@ -9448,16 +9705,17 @@ declare module 'alinea/dashboard/app/EntryValidationModal' {
 
   import type { FieldValidationError } from 'alinea/core/Validation';
   export interface EntryValidationFailure {
-      errors?: Array<FieldValidationError>;
-      /** Shown when the errors came back from the server without details */
-      message?: string;
+      errors: Array<FieldValidationError>;
+      /** Publishes the entry as it is */
+      publish(): void | Promise<void>;
   }
   export interface EntryValidationModalProps {
       failure?: EntryValidationFailure;
       onClose(): void;
+      onPublish(publish: () => void | Promise<void>): void;
   }
-  /** Explains why an entry cannot be published and lists the invalid fields */
-  export function EntryValidationModal({ failure, onClose }: EntryValidationModalProps): import("react").JSX.Element;
+  /** Lists the invalid fields of an entry about to be published */
+  export function EntryValidationModal({ failure, onClose, onPublish }: EntryValidationModalProps): import("react").JSX.Element;
   
 }
 
@@ -9500,6 +9758,8 @@ declare module 'alinea/dashboard/app/Explorer' {
        */
       onPick?: (entry: DashboardEntry) => void;
       page: ExplorerReadyPage;
+      /** Floats over the list, such as the actions on the selected entries */
+      children?: ReactNode;
   }
   interface ExplorerSearchProps {
       autoFocus?: boolean;
@@ -9510,7 +9770,7 @@ declare module 'alinea/dashboard/app/Explorer' {
   }
   export function ExplorerSearch({ autoFocus, explorer, onEntryAction, onEscape, page }: ExplorerSearchProps): import("react").JSX.Element;
   export function ExplorerHeader({ canBrowse, autoFocusSearch, onSearchEscape, controls, explorer, headerEntry, navigate, page, readOnly, titleControls }: ExplorerHeaderProps): import("react").JSX.Element;
-  export function ExplorerBody({ compactTable, explorer, onPick, page }: ExplorerBodyProps): import("react").JSX.Element;
+  export function ExplorerBody({ compactTable, explorer, onPick, page, children }: ExplorerBodyProps): import("react").JSX.Element;
   export function Explorer({ controls, explorer, headerEntry, page: loadedPage, readOnly, titleControls }: ExplorerProps): import("react").JSX.Element;
   export {};
   
@@ -9526,14 +9786,16 @@ declare module 'alinea/dashboard/app/ExplorerBatchActions' {
   export function ExplorerBatchActions({ explorer }: ExplorerBatchActionsProps): import("react").JSX.Element | null;
   export interface ExplorerBatchActionBarProps {
       count: number;
+      /** Every selected entry can be deleted */
       canDelete: boolean;
+      /** Every selected entry can be moved */
       canMove: boolean;
       isPending?: boolean;
       onClear(): void;
       onDelete(): void;
       onMove(): void;
   }
-  /** Shows how many entries are selected and the actions on them */
+  /** Floats over the list: how many entries are selected and their actions */
   export function ExplorerBatchActionBar({ count, canDelete, canMove, isPending, onClear, onDelete, onMove }: ExplorerBatchActionBarProps): import("react").JSX.Element;
   
 }
@@ -9828,6 +10090,16 @@ declare module 'alinea/dashboard/app/modals/CreateEntry' {
   
 }
 
+declare module 'alinea/dashboard/app/MoveConfirmDialog' {
+
+  /**
+   * Asks before a drag moves pages under another parent, changing their urls,
+   * or tells why the dragged entries can not move there
+   */
+  export function MoveConfirmDialog(): import("react").JSX.Element;
+  
+}
+
 declare module 'alinea/dashboard/app/MoveDialog' {
 
   import { type MoveTargets } from 'alinea/dashboard/atoms/move';
@@ -9882,7 +10154,8 @@ declare module 'alinea/dashboard/app/OverviewCell' {
 declare module 'alinea/dashboard/app/pages/EntryPage' {
 
   import { Page } from 'alinea/dashboard/atoms/nav';
-  export const entryPage: (page: Page, get: import("jotai").Getter) => import("react").ReactNode | Promise<import("react").ReactNode>;
+  import { type ReactNode } from 'react';
+  export const entryPage: (page: Page, get: import("jotai").Getter) => ReactNode | Promise<ReactNode>;
   export interface NotFoundPanelProps {
       title: string;
       message: string;
@@ -10001,12 +10274,60 @@ declare module 'alinea/dashboard/app/PendingUploadsView' {
 declare module 'alinea/dashboard/app/ReadOnlyBadge' {
 
   import type { ComponentPropsWithoutRef } from 'react';
-  export interface ReadOnlyBadgeProps extends ComponentPropsWithoutRef<'span'> {
+  export interface ReadOnlyBadgeProps extends Omit<ComponentPropsWithoutRef<'span'>, 'color'> {
   }
   export function ReadOnlyBadge(props: ReadOnlyBadgeProps): import("react").JSX.Element;
   
 }
 
+declare module 'alinea/dashboard/app/RemoveDialog' {
+
+  import { type RemoveAction, type RemovePlan } from 'alinea/dashboard/atoms/remove';
+  export interface RemoveDialogProps {
+      action: RemoveAction;
+      /** What to remove, loaded before it opens, closed when undefined */
+      plan: RemovePlan | undefined;
+      onClose(): void;
+      /** Deletes or archives the entries, as the action says */
+      onConfirm(plan: RemovePlan): Promise<void>;
+      /** Archives the entries instead of deleting them, offered when all of them
+       * can be */
+      onArchive?(plan: RemovePlan): Promise<void>;
+  }
+  /**
+   * Confirms deleting or archiving entries, warning about the links that will
+   * break, and redirects their URLs to another page
+   */
+  export function RemoveDialog({ action, plan, onClose, onConfirm, onArchive }: RemoveDialogProps): import("react").JSX.Element;
+  
+}
+
+declare module 'alinea/dashboard/app/RemoveRedirect' {
+
+  import { type RemovePlan } from 'alinea/dashboard/atoms/remove';
+  export interface RemoveRedirectProps {
+      plan: RemovePlan;
+      disabled?: boolean;
+  }
+  /** Picks a page the URLs of the removed pages redirect to */
+  export function RemoveRedirect({ plan, disabled }: RemoveRedirectProps): import("react").JSX.Element | null;
+  
+}
+
+declare module 'alinea/dashboard/app/SearchBar' {
+
+  import type { ReactNode } from 'react';
+  export interface SearchBarProps {
+      /** The search field, inline so it reads as the row itself */
+      children: ReactNode;
+      /** Compact controls at the end of the row, after a divider */
+      controls?: ReactNode;
+  }
+  /** A search field as the top row of the results it searches */
+  export function SearchBar({ children, controls }: SearchBarProps): import("react").JSX.Element;
+  
+}
+
 declare module 'alinea/dashboard/app/SidebarLayout' {
 
   import type { ReactNode } from 'react';
@@ -10382,79 +10703,6 @@ declare module 'alinea/dashboard/atoms/dashboard' {
   
 }
 
-declare module 'alinea/dashboard/atoms/delete' {
-
-  import type { EntryReference } from 'alinea/core/db/EntryReference';
-  import { type Atom, type PrimitiveAtom } from 'jotai';
-  import { type EntryReferenceWithSource } from 'alinea/dashboard/atoms/entry';
-  /** An entry that is about to be deleted, in the locale it is shown in */
-  export interface DeleteSubject {
-      id: string;
-      title: string;
-      type: string;
-      workspace: string;
-      root: string;
-      /** Null for entries without languages */
-      locale: string | null;
-      parents: Array<string>;
-      hasChildren: boolean;
-  }
-  /** A translation that is removed, a null locale removes every version */
-  export interface DeleteRemoval {
-      id: string;
-      locale: string | null;
-  }
-  /** An entry that is deleted with the translation of its parent */
-  export interface DeleteDescendant extends DeleteRemoval {
-      subjectId: string;
-  }
-  /** Which languages of the entries are deleted and the links that will break */
-  export interface DeletePlan {
-      subjects: Array<DeleteSubject>;
-      /** The languages of a single entry the user can pick to delete, undefined
-       * for a batch */
-      locales?: Array<string>;
-      /** The picked languages, the shown language at first */
-      selectedLocales: PrimitiveAtom<Array<string>>;
-      removals: Atom<Array<DeleteRemoval>>;
-      /** The versions linking to the removed translations and their contents,
-       * that are not removed themselves */
-      references: Atom<Array<EntryReferenceWithSource>>;
-      /** How many entries the user can not read link to them, their titles stay
-       * hidden */
-      hiddenSources: Atom<number>;
-      /** Every removed translation is published and can be archived instead */
-      archivable: Atom<boolean>;
-  }
-  export interface DeletePlanOptions {
-      subjects: Array<DeleteSubject>;
-      locales?: Array<string>;
-      references?: Array<EntryReferenceWithSource>;
-      /** Links from versions the user can not read */
-      hidden?: Array<EntryReference>;
-      descendants?: Array<DeleteDescendant>;
-      /** The translations that can be archived */
-      archivable?: Array<DeleteRemoval>;
-  }
-  /**
-   * Entries without languages are deleted entirely, the others in the picked
-   * languages or, in a batch, the language they are shown in.
-   */
-  export function createDeletePlan({ subjects, locales, references, hidden, descendants, archivable }: DeletePlanOptions): DeletePlan;
-  /** Loads the references to the entries before the delete dialog opens */
-  export const loadDeletePlanAtom: import("jotai").WritableAtom<null, [subjects: DeleteSubject[], locales?: string[] | undefined], Promise<DeletePlan>> & {
-      init: null;
-  };
-  export const deleteEntriesAtom: import("jotai").WritableAtom<null, [plan: DeletePlan], Promise<void>> & {
-      init: null;
-  };
-  /** Archives the translations the plan would delete */
-  export const archiveEntriesAtom: import("jotai").WritableAtom<null, [plan: DeletePlan], Promise<void>> & {
-      init: null;
-  };
-  
-}
-
 declare module 'alinea/dashboard/atoms/editor' {
 
   import { Field, type EntryAnchorTarget, type FieldOptions } from 'alinea/core/Field';
@@ -10867,6 +11115,8 @@ declare module 'alinea/dashboard/atoms/explorer' {
       initialSearchScope?: 'workspace' | 'everything';
       location?: ExplorerLocation;
       limitLocations?: Array<ExplorerLimitLocation>;
+      /** Lists only the media roots, for pickers of files and images */
+      media?: boolean;
       mode?: 'browse' | 'search';
       nestedNavigation?: boolean;
       /**
@@ -10971,6 +11221,8 @@ declare module 'alinea/dashboard/atoms/explorer' {
       createdAt?: number | null;
       id: string;
       status?: EntryStatus;
+      /** The version is the main one, a draft then was never published */
+      main?: boolean;
       title: string;
       path: string;
       updatedAt?: number | null;
@@ -11299,6 +11551,11 @@ declare module 'alinea/dashboard/atoms/move' {
        * and entries missing a language of the moved entries are not a target
        */
       canSelect(item: ExplorerItemData): boolean;
+      /**
+       * Why the entries can not move into `parent`, or to the top level of the
+       * root with null; undefined when they can
+       */
+      refusal(parent: MoveSubject | null): string | undefined;
       /** The entries can be moved to the top level of the root */
       rootAccepts: boolean;
   }
@@ -11334,9 +11591,48 @@ declare module 'alinea/dashboard/atoms/move' {
   
 }
 
+declare module 'alinea/dashboard/atoms/moveConfirmation' {
+
+  import type { DropTarget, Key } from 'alinea/components';
+  /**
+   * A dragged move to confirm: the pages it gives another parent, and so
+   * another url, or why it can not move there
+   */
+  export interface MoveConfirmation {
+      pages: Array<{
+          id: string;
+          title: string;
+      }>;
+      refusal?: string;
+      resolve(confirmed: boolean): void;
+  }
+  /** Whether moving pages asks first, until the editor stops it here */
+  export const confirmMovesAtom: import("jotai").WritableAtom<boolean, [boolean | typeof import("jotai/utils").RESET | ((prev: boolean) => boolean | typeof import("jotai/utils").RESET)], void>;
+  /**
+   * The entries being dragged, known from the start of a drag so that drop
+   * targets can turn down the ones they can not hold
+   */
+  export const draggedEntriesAtom: import("jotai").PrimitiveAtom<ReadonlySet<Key>> & {
+      init: ReadonlySet<Key>;
+  };
+  export const moveConfirmationAtom: import("jotai").PrimitiveAtom<MoveConfirmation | undefined> & {
+      init: MoveConfirmation | undefined;
+  };
+  /**
+   * Whether entries dropped on a target can move there, and the editor agrees:
+   * entries that get another parent follow the rules of moving them with the
+   * move dialog, and entries of a document type ask first, as their url and
+   * those of the pages below them change.
+   */
+  export const confirmMoveAtom: import("jotai").WritableAtom<null, [ids: Iterable<string>, target: DropTarget], Promise<boolean>> & {
+      init: null;
+  };
+  
+}
+
 declare module 'alinea/dashboard/atoms/nav' {
 
-  import { Atom, Getter } from 'jotai';
+  import { Atom, type Getter } from 'jotai';
   import type { OverviewSort } from 'alinea/core/Overview';
   import type { EntryDefaultView } from 'alinea/core/Type';
   import { ReactNode } from 'react';
@@ -11350,7 +11646,9 @@ declare module 'alinea/dashboard/atoms/nav' {
       init: RouteBlock | null;
   };
   export interface DashboardRoute {
-      page?: 'splash' | 'entry' | 'users';
+      /** An edit link names an entry by its url, until it is looked up */
+      page?: 'splash' | 'entry' | 'users' | 'edit';
+      url?: string;
       workspace?: string;
       root?: string;
       entry?: string;
@@ -11362,11 +11660,13 @@ declare module 'alinea/dashboard/atoms/nav' {
       replace?: boolean;
   }
   interface ResolvedDashboardRoute extends DashboardRoute {
-      page: 'splash' | 'entry' | 'users';
+      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 */
@@ -11378,11 +11678,11 @@ declare module 'alinea/dashboard/atoms/nav' {
       route: ResolvedDashboardRoute;
   }
   /** @internal */
-  export const routeAtom: import("jotai").WritableAtom<ResolvedDashboardRoute, [update: DashboardRoute | NavigationRequest], void> & {
+  export const routeAtom: import("jotai").WritableAtom<ResolvedDashboardRoute, [update: DashboardRoute | NavigationRequest], void | Promise<void>> & {
       onMount(navigate: (request: NavigationRequest) => void): (() => void) | undefined;
   };
   export interface Page {
-      type: 'splash' | 'users' | 'entry';
+      type: 'splash' | 'users' | 'entry' | 'edit';
       workspace: string | undefined;
       root: string | undefined;
       requestedRoot?: string;
@@ -11416,7 +11716,7 @@ declare module 'alinea/dashboard/atoms/overview' {
   import { Type } from 'alinea/core/Type';
   import type { View } from 'alinea/core/View';
   /** The columns every overview can show next to its configured columns */
-  export type OverviewBuiltinColumn = 'type' | 'status' | 'updated' | 'author';
+  export type OverviewBuiltinColumn = 'type' | 'updated' | 'author';
   /** The number of `overview: true` fields shown when a parent has no columns */
   export const overviewFieldColumnLimit = 5;
   /** Where a list of entries lives, its overview is configured there */
@@ -11514,7 +11814,7 @@ declare module 'alinea/dashboard/atoms/overview' {
        */
       mixed?: boolean;
       /**
-       * The listed children grouped by type and status, see `summarizeRows`.
+       * The listed children grouped by type, see `summarizeRows`.
        * The columns then follow the children: the types present, and built-in
        * columns only when they tell the children apart.
        */
@@ -11563,6 +11863,8 @@ declare module 'alinea/dashboard/atoms/overview' {
       path: string;
       url?: string;
       status?: EntryStatus;
+      /** The version is the main one, a draft then was never published */
+      main?: boolean;
       locale: string | null;
       workspace: string;
       root: string;
@@ -11591,17 +11893,16 @@ declare module 'alinea/dashboard/atoms/overview' {
   export const openEntryAtom: import("jotai").WritableAtom<null, [id: string, locale: string | null], Promise<void>> & {
       init: null;
   };
-  /** The listed children that share a type and status */
+  /** The listed children that share a type */
   export interface OverviewChildren {
       type: string;
-      status: EntryStatus;
       /** Some of these children store when they were last edited */
       updatedAt: boolean;
       /** Some of these children store who last edited them */
       updatedBy: boolean;
   }
   /**
-   * Groups rows by type and status, noting whether they store audit
+   * Groups rows by type, noting whether they store audit
    * metadata. Lists load every child of their parent and searches their
    * shown results, so this covers every row and the columns stay put.
    */
@@ -11667,12 +11968,129 @@ declare module 'alinea/dashboard/atoms/ReactiveNode' {
   
 }
 
+declare module 'alinea/dashboard/atoms/remove' {
+
+  import type { Config } from 'alinea/core/Config';
+  import type { EntryReference } from 'alinea/core/db/EntryReference';
+  import type { EntryFields } from 'alinea/core/EntryFields';
+  import type { Filter } from 'alinea/core/Filter';
+  import type { Policy } from 'alinea/core/Role';
+  import { type Atom, type PrimitiveAtom } from 'jotai';
+  import { type EntryReferenceWithSource } from 'alinea/dashboard/atoms/entry';
+  import type { ExplorerItemData, ExplorerLimitLocation } from 'alinea/dashboard/atoms/explorer';
+  /** Deleting removes the entries, archiving unpublishes them until restored */
+  export type RemoveAction = 'delete' | 'archive';
+  /** An entry that is about to be removed, in the locale it is shown in */
+  export interface RemoveSubject {
+      id: string;
+      title: string;
+      type: string;
+      workspace: string;
+      root: string;
+      /** Null for entries without languages */
+      locale: string | null;
+      parents: Array<string>;
+      hasChildren: boolean;
+  }
+  /** A translation that is removed, a null locale removes every version */
+  export interface Removal {
+      id: string;
+      locale: string | null;
+  }
+  /** An entry that is removed with the translation of its parent */
+  export interface RemovedDescendant extends Removal {
+      subjectId: string;
+  }
+  /** The public URL of a removed translation of a page */
+  export interface RemovedUrl extends Removal {
+      url: string;
+  }
+  /** The page the URLs of the removed pages redirect to */
+  export interface RedirectTarget {
+      id: string;
+      title: string;
+      url: string;
+      /** The languages of its versions, null for an entry without languages */
+      locales: Array<string | null>;
+  }
+  /** Which languages of the entries are removed and the links that will break */
+  export interface RemovePlan {
+      subjects: Array<RemoveSubject>;
+      /** The languages of a single entry the user can pick to delete, undefined
+       * for a batch */
+      locales?: Array<string>;
+      /** The picked languages, the shown language at first */
+      selectedLocales: PrimitiveAtom<Array<string>>;
+      removals: Atom<Array<Removal>>;
+      /** The versions linking to the removed translations and their contents,
+       * that are not removed themselves */
+      references: Atom<Array<EntryReferenceWithSource>>;
+      /** How many entries the user can not read link to them, their titles stay
+       * hidden */
+      hiddenSources: Atom<number>;
+      /** Every removed translation is published and can be archived instead */
+      archivable: Atom<boolean>;
+      /** The public URLs of the removed translations of pages */
+      urls: Atom<Array<RemovedUrl>>;
+      /** The page the editor picked to redirect the URLs to */
+      redirect: PrimitiveAtom<RedirectTarget | undefined>;
+      /** The URLs the redirect target has no version for, they don't redirect */
+      unredirected: Atom<Array<RemovedUrl>>;
+  }
+  export interface RemovePlanOptions {
+      subjects: Array<RemoveSubject>;
+      locales?: Array<string>;
+      references?: Array<EntryReferenceWithSource>;
+      /** Links from versions the user can not read */
+      hidden?: Array<EntryReference>;
+      descendants?: Array<RemovedDescendant>;
+      /** The translations that can be archived */
+      archivable?: Array<Removal>;
+      /** The public URLs of the subjects, in each of their languages */
+      urls?: Array<RemovedUrl>;
+  }
+  /**
+   * Entries without languages are removed entirely, the others in the picked
+   * languages or, in a batch, the language they are shown in.
+   */
+  export function createRemovePlan({ subjects, locales, references, hidden, descendants, archivable, urls }: RemovePlanOptions): RemovePlan;
+  export interface RedirectPicker {
+      /** The entries of the types that hold URL aliases */
+      condition: Filter<EntryFields>;
+      /** The roots of the workspace of the removed entries */
+      locations: Array<ExplorerLimitLocation>;
+      /** Entries that are not removed and the user may add an alias to */
+      canSelect(item: ExplorerItemData): boolean;
+  }
+  /** Which pages the URLs of the removed entries can redirect to */
+  export function redirectPicker(config: Config, policy: Policy, subjects: Array<RemoveSubject>): RedirectPicker;
+  /** Loads the page the editor picked to redirect the URLs to */
+  export const loadRedirectTargetAtom: import("jotai").WritableAtom<null, [id: string, locale: string | null], Promise<RedirectTarget | undefined>> & {
+      init: null;
+  };
+  /** Loads the references to the entries before the remove dialog opens */
+  export const loadRemovePlanAtom: import("jotai").WritableAtom<null, [subjects: RemoveSubject[], locales?: string[] | undefined], Promise<RemovePlan>> & {
+      init: null;
+  };
+  /** Removes the translations and redirects their URLs in one commit */
+  export const deleteEntriesAtom: import("jotai").WritableAtom<null, [plan: RemovePlan], Promise<void>> & {
+      init: null;
+  };
+  /** Archives the translations the plan would delete */
+  export const archiveEntriesAtom: import("jotai").WritableAtom<null, [plan: RemovePlan], Promise<void>> & {
+      init: null;
+  };
+  /** Archive without asking first, until the browser session ends */
+  export const archiveDirectlyAtom: import("jotai").WritableAtom<boolean, [boolean | typeof import("jotai/utils").RESET | ((prev: boolean) => boolean | typeof import("jotai/utils").RESET)], void>;
+  
+}
+
 declare module 'alinea/dashboard/atoms/root' {
 
+  import { Config } from 'alinea/core/Config';
   import type { EntryStatus } from 'alinea/core/Entry';
   import { Permission } from 'alinea/core/Role';
   import { type RootData, type RootI18n } from 'alinea/core/Root';
-  import { Schema } from 'alinea/core/Schema';
   import { ExplorerAtoms } from 'alinea/dashboard/atoms/explorer';
   import { type Atom, type PrimitiveAtom } from 'jotai';
   import type { ComponentType } from 'react';
@@ -11784,7 +12202,7 @@ declare module 'alinea/dashboard/atoms/root' {
    * Entries can be dropped on a container, but only placed before or after the
    * children of a parent that does not order them, and never inside themselves
    */
-  export function treeAcceptsDrop(schema: Schema, entries: Map<string, RootTreeItem>, target: DropTarget, keys?: ReadonlySet<Key>): boolean;
+  export function treeAcceptsDrop(config: Config, rootData: RootData, entries: Map<string, RootTreeItem>, target: DropTarget, keys?: ReadonlySet<Key>): boolean;
   /** The selected entry, or the location of a selected entry that is not listed */
   export function locatedItem({ entries, snapshot }: TreeView): RootTreeItem | undefined;
   export {};
@@ -12037,6 +12455,7 @@ declare module 'alinea/dashboard/boot/DashboardWorker' {
   import { type Activity } from 'alinea/dashboard/boot/ActivityEvent';
   export class DashboardWorker extends EventTarget {
       #private;
+      /** Keep the content in memory with `source`, instead of in the browser. */
       constructor(source?: Source);
       get db(): EntryStore | Promise<EntryStore>;
       sync(): Promise<string>;
@@ -13010,6 +13429,7 @@ declare module 'alinea/dashboard/ViewKeys' {
       MetadataUserInput: string;
       MetadataInput: string;
       MetadataDetailsView: string;
+      MetadataPreviewsView: string;
       NumberInput: string;
       ObjectInput: string;
       PathInput: string;
@@ -13027,86 +13447,36 @@ declare module 'alinea/dashboard/ViewKeys' {
 declare module 'alinea/database/BrowserEntryStore' {
 
   import type { Config } from 'alinea/core/Config';
-  import type { Mutation } from 'alinea/core/db/Mutation';
-  import type { CommitRequest } from 'alinea/core/db/CommitRequest';
   import type { SyncOptions } from 'alinea/core/db/LocalStore';
   import type { RemoteSource } from 'alinea/core/source/Source';
+  import { type SnapshotStorage } from '@alinea/sqlite-wasm/snapshots';
   import { EntryStore } from 'alinea/database/EntryStore';
   export interface BrowserEntryStoreOptions {
       name: string;
-      revision: string;
+      /** Stores of one config fingerprint open the bases it wrote. */
+      fingerprint: string;
+      /** Where bases are kept, Blobs in IndexedDB by default. */
+      storage?: SnapshotStorage;
       /**
-       * Start over from an empty database instead of the stored one, such as
+       * Start over from an empty database instead of a stored base, such as
        * when it turned out to be corrupt.
        */
       reset?: boolean;
-      /** The IndexedDB implementation, the global one by default. */
-      indexedDB?: IDBFactory;
-      IDBKeyRange?: typeof IDBKeyRange;
-      /** The Web Locks implementation, the global one by default. */
-      locks?: CacheLocks;
-  }
-  /** The part of the Web Locks API that keeps a cache to one worker. */
-  export interface CacheLocks {
-      request(name: string, options: {
-          ifAvailable?: boolean;
-          signal?: AbortSignal;
-      }, callback: (lock: Lock | null) => Promise<void> | void): Promise<unknown>;
-  }
-  export interface HoldCacheOptions {
-      /**
-       * How long to wait, in milliseconds, for another worker that holds the
-       * cache to end: none by default, Infinity until it does.
-       */
-      wait?: number;
-      /** The Web Locks implementation, the global one by default. */
-      locks?: CacheLocks;
   }
   /**
-   * Hold the cache called `name` for as long as this worker runs, and resolve
-   * with whether it does. Nothing coordinates two stores writing the same
-   * pages, which corrupts them, so only the worker that holds the cache opens
-   * it; another one, such as one of another dashboard build, reads a
-   * snapshot. Without Web Locks, or if they refuse, no worker holds it.
-   */
-  export function holdCache(name: string, options?: HoldCacheOptions): Promise<boolean>;
-  /**
-   * WASM entry store kept in IndexedDB: every commit stores the pages it
-   * changed.
+   * WASM entry store on a copy-on-write overlay over the newest stored base:
+   * it reads pages from the base as queries need them, and keeps its changes
+   * in memory. Every sync stores them as a new base in the background, which
+   * the next store opens; the stored bases never change, so stores of any
+   * number of workers and dashboard builds can use them at once.
    */
   export class BrowserEntryStore extends EntryStore {
       #private;
-      /**
-       * Open the store kept in IndexedDB. Only the worker that holds the cache
-       * opens it (see `holdCache`), and deletes the caches of other versions.
-       */
       static open(config: Config, options: BrowserEntryStoreOptions): Promise<BrowserEntryStore>;
-      /**
-       * A copy in memory of the stored content, for a worker that cannot store
-       * it while another one does: it loads the last committed state and never
-       * writes. Resolves with undefined if that state cannot be read.
-       */
-      static snapshot(config: Config, options: BrowserEntryStoreOptions): Promise<EntryStore | undefined>;
       private constructor();
-      /**
-       * Opening, and syncing, resolve once the content is in memory: storing it
-       * is a cache that finishes in the background, which takes seconds for a
-       * first sync or a rebuild of a large project.
-       */
       sync(): Promise<string>;
       syncWith(remote: RemoteSource, options?: SyncOptions): Promise<string>;
-      mutate(mutations: Array<Mutation>): Promise<{
-          sha: string;
-      }>;
-      write(request: CommitRequest): Promise<{
-          sha: string;
-      }>;
-      /**
-       * Stop storing, and resolve once the commits so far are stored, for a
-       * replacement to open the cache. Work in flight then changes only this
-       * store's memory, so the replacement need not wait for it.
-       */
-      release(): Promise<void>;
+      /** Close once the last checkpoint is stored. */
       close(): Promise<void>;
   }
   /** Whether an error, or one it holds, reports a damaged SQLite database. */
@@ -13230,7 +13600,7 @@ declare module 'alinea/database/driver/RuntimeDatabase' {
 
 declare module 'alinea/database/driver/WasmDatabase' {
 
-  import type { Storage } from '@alinea/sqlite-wasm/Database.js';
+  import type { Database as WasmSqlite } from '@alinea/sqlite-wasm/Database.js';
   import type { DatabaseOptions } from 'rado';
   import { connect } from 'rado/driver/sql.js';
   import type { DatabaseHandle } from 'alinea/database/driver/DatabaseHandle';
@@ -13238,24 +13608,11 @@ declare module 'alinea/database/driver/WasmDatabase' {
       database: ReturnType<typeof connect>;
       fork(): Promise<WasmDatabaseHandle>;
       export(): Uint8Array;
-      /** Resolves once every commit so far is stored; at once in memory. */
-      flush(): Promise<void>;
-      /**
-       * Store this database from now on, replacing what the storage held, once
-       * a database detached from it wrote its last commits.
-       */
-      attach(storage: Storage): Promise<void>;
-      /**
-       * Stop storing commits once the ones so far are written; later commits
-       * change only the memory copy.
-       */
-      detach(): void;
   }
-  /**
-   * Open a WASM connection from the database kept in storage, or an empty one,
-   * that stores every commit there.
-   */
-  export function syncWasmDatabase(storage: Storage, options?: DatabaseOptions): Promise<WasmDatabaseHandle>;
+  /** The WASM SQLite database class, loaded on first use. */
+  export function wasmSqlite(): Promise<new () => WasmSqlite>;
+  /** Connect to `sqlite`; forks keep its page cache size. */
+  export function wasmHandle(sqlite: WasmSqlite, options?: DatabaseOptions): WasmDatabaseHandle;
   /** Open an in-memory WASM connection, optionally from a complete SQLite file. */
   export function openWasmDatabase(data?: Uint8Array, options?: DatabaseOptions): Promise<WasmDatabaseHandle>;
   export function wasmDatabase(data?: Uint8Array): Promise<import("rado").SyncDatabase<"sqlite">>;
@@ -13675,7 +14032,11 @@ declare module 'alinea/database/EntryTransaction' {
 declare module 'alinea/database/EntryUrlAliases' {
 
   import { Type } from 'alinea/core/Type';
+  /** Entries of the type keep URL aliases in their metadata */
+  export function hasUrlAliases(type: Type): boolean;
   export function dataWithUrlAlias(type: Type, data: Record<string, unknown>, previousUrl: string, currentUrl: string): Record<string, unknown>;
+  /** Adds the urls that are not an alias yet to the aliases in the metadata */
+  export function dataWithUrlAliases(data: Record<string, unknown>, urls: Array<string>): Record<string, unknown>;
   
 }
 
@@ -14470,10 +14831,10 @@ declare module 'alinea/field/link/EntryLink' {
   import type { Label } from 'alinea/core/Label';
   import type { Type } from 'alinea/core/Type';
   import type { ListRow } from 'alinea/core/ListRow';
-  import { type LinkFieldOptions } from 'alinea/field/link/LinkField';
+  import { type LinkFieldOptions, type LinkFields } from 'alinea/field/link/LinkField';
   import { type EntryPickerOptions } from 'alinea/picker/entry';
   import type { EntryReference } from 'alinea/picker/entry/EntryReference';
-  export interface EntryLink<InferredFields = undefined> extends EntryReference {
+  export interface EntryLink<InferredFields = {}> extends EntryReference {
       entryId: string;
       entryType: string;
       title: string;
@@ -14492,9 +14853,9 @@ declare module 'alinea/field/link/EntryLink' {
   }
   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<{ [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 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 namespace entry {
-      type EntryRow<Fields> = EntryLink<Type.Infer<Fields>> & ListRow;
+      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>>;
@@ -14510,10 +14871,10 @@ declare module 'alinea/field/link/FileLink' {
   import type { InferStoredValue } from 'alinea/core/Infer';
   import type { Label } from 'alinea/core/Label';
   import type { ListRow } from 'alinea/core/ListRow';
-  import { type LinkFieldOptions } from 'alinea/field/link/LinkField';
+  import { type LinkFieldOptions, type LinkFields } from 'alinea/field/link/LinkField';
   import { type EntryPickerOptions } from 'alinea/picker/entry';
   import type { EntryReference } from 'alinea/picker/entry/EntryReference';
-  export interface FileLink<InferredFields = undefined> extends EntryReference {
+  export interface FileLink<InferredFields = {}> extends EntryReference {
       title: string;
       /** Public url of the file */
       url: string;
@@ -14533,11 +14894,11 @@ declare module 'alinea/field/link/FileLink' {
   export function filePicker<Fields>(multiple: boolean, options: Omit<EntryPickerOptions<Fields>, 'selection'>): import("alinea/core/Picker").Picker<EntryReference, EntryPickerOptions<Fields>>;
   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<{ [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 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 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<{ [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>>;
+      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>>>;
   }
   
 }
@@ -14549,10 +14910,10 @@ declare module 'alinea/field/link/ImageLink' {
   import type { Label } from 'alinea/core/Label';
   import type { Type } from 'alinea/core/Type';
   import type { ListRow } from 'alinea/core/ListRow';
-  import { type LinkField, type LinkFieldOptions, type LinksField } from 'alinea/field/link/LinkField';
+  import { type LinkField, type LinkFieldOptions, type LinksField, type LinkFields } from 'alinea/field/link/LinkField';
   import { type EntryPickerOptions } from 'alinea/picker/entry';
   import type { EntryReference } from 'alinea/picker/entry/EntryReference';
-  export interface ImageLink<InferredFields = undefined> extends EntryReference {
+  export interface ImageLink<InferredFields = {}> extends EntryReference {
       title: string;
       alt?: string;
       /** Public url of the image file, versioned by its hash */
@@ -14589,12 +14950,12 @@ declare module 'alinea/field/link/ImageLink' {
           y: number;
       }>;
   }
-  export interface ImageField<Fields = undefined> extends LinkField<EntryReference & InferStoredValue<Fields>, ImageLink<Type.Infer<Fields>>> {
+  export interface ImageField<Fields = undefined> extends LinkField<EntryReference & InferStoredValue<Fields>, ImageLink<LinkFields<Type.Infer<Fields>>>> {
   }
   export interface ImageOptions<Fields> extends LinkFieldOptions<EntryReference & InferStoredValue<Fields>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
   }
   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<Type.Infer<Fields>>> {
+  export interface ImagesField<Fields = undefined> extends LinksField<EntryReference & ListRow & InferStoredValue<Fields>, ImageLink<LinkFields<Type.Infer<Fields>>>> {
   }
   export namespace image {
       interface ImagesOptions<Fields> extends LinkFieldOptions<Array<EntryReference & ListRow & InferStoredValue<Fields>>>, Omit<EntryPickerOptions<Fields>, 'label' | 'selection'> {
@@ -14617,7 +14978,7 @@ declare module 'alinea/field/link/Link' {
   import { type UrlReference } from 'alinea/picker/url';
   import { EntryLink } from 'alinea/field/link/EntryLink';
   import type { UrlLink } from 'alinea/field/link/UrlLink';
-  export type Link<InferredFields> = EntryLink<InferredFields> | UrlLink<InferredFields> | FileLink<InferredFields>;
+  export type Link<InferredFields = {}> = EntryLink<InferredFields> | UrlLink<InferredFields> | FileLink<InferredFields>;
   export interface LinkOptions<Definition, Row> extends LinkFieldOptions<Row>, EntryPickerConditions {
       fields?: Definition | Type<Definition>;
   }
@@ -14671,6 +15032,11 @@ declare module 'alinea/field/link/LinkField' {
   import { ListRow } from 'alinea/core/ListRow';
   import type { ReactNode } from 'react';
   /** Optional settings to configure a link field */
+  /**
+   * The extra fields of a queried link: a link without extra fields holds an
+   * empty object, which is also what the link types default to
+   */
+  export type LinkFields<InferredFields> = InferredFields extends undefined ? {} : InferredFields;
   export interface LinkFieldOptions<Value> extends FieldOptions<Value> {
       /**
        * Allow the same entry to be linked more than once.
@@ -14733,9 +15099,9 @@ declare module 'alinea/field/link/UrlLink' {
   import type { Label } from 'alinea/core/Label';
   import type { Type } from 'alinea/core/Type';
   import type { ListRow } from 'alinea/core/ListRow';
-  import { type LinkFieldOptions } from 'alinea/field/link/LinkField';
+  import { type LinkFieldOptions, type LinkFields } from 'alinea/field/link/LinkField';
   import { type UrlPickerOptions, type UrlReference } from 'alinea/picker/url';
-  export interface UrlLink<InferredFields = undefined> extends UrlReference {
+  export interface UrlLink<InferredFields = {}> extends UrlReference {
       url: string;
       href: string;
       title: string;
@@ -14746,9 +15112,9 @@ declare module 'alinea/field/link/UrlLink' {
   }
   export interface UrlOptions<Fields> extends LinkFieldOptions<UrlReference & InferStoredValue<Fields>>, UrlPickerOptions<Fields> {
   }
-  export function url<Fields>(label: Label, options?: WithoutLabel<UrlOptions<Fields>>): import("alinea/field/link/LinkField").LinkField<UrlReference & InferStoredValue<Fields>, UrlLink<{ [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 function url<Fields>(label: Label, options?: WithoutLabel<UrlOptions<Fields>>): import("alinea/field/link/LinkField").LinkField<UrlReference & InferStoredValue<Fields>, UrlLink<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 namespace url {
-      type UrlRows<Fields> = UrlLink<Type.Infer<Fields>> & ListRow;
+      type UrlRows<Fields> = UrlLink<LinkFields<Type.Infer<Fields>>> & ListRow;
       export interface UrlOptions<Fields> extends LinkFieldOptions<Array<UrlReference & ListRow & InferStoredValue<Fields>>>, UrlPickerOptions<Fields> {
       }
       export function multiple<Fields>(label: Label, options?: WithoutLabel<UrlOptions<Fields>>): import("alinea/field/link/LinkField").LinksField<UrlReference & ListRow & InferStoredValue<Fields>, UrlRows<Fields>>;
@@ -14781,6 +15147,8 @@ declare module 'alinea/field/list/ListField' {
       help?: ReactNode;
       /** Display a minimal version */
       inline?: boolean;
+      /** Show the rows folded when the entry opens, added rows start open */
+      collapsed?: boolean;
       /** Hide this list field */
       hidden?: boolean;
       /** Mark the field as invalid while it has fewer items */
@@ -14810,12 +15178,27 @@ declare module 'alinea/field/list/ListField.view' {
       _type: string;
       [key: string]: unknown;
   }
+  export interface ListFieldTypeItem {
+      id: string;
+      label: string;
+      type: Schema[string];
+  }
   export interface ListFieldViewProps {
       field: CoreListField<ListRow, ListValue, ListOptions<Schema>>;
   }
   export function ListFieldView({ field }: ListFieldViewProps): import("react").JSX.Element;
   export function insertIndex(rowIndex: number, position: 'before' | 'after'): number;
   export function reorderIndex(fromIndex: number, targetIndex: number): number;
+  export interface ListFieldTypeCommandProps {
+      items: Array<ListFieldTypeItem>;
+      label: string;
+      pasted?: ListValue;
+      pasteLabel?: string;
+      onPaste?: (row: ListValue) => void;
+      onSelect: (item: ListFieldTypeItem) => void;
+  }
+  /** Searchable list of block types, also used to insert rich text blocks */
+  export function ListFieldTypeCommand({ items, label, pasted, pasteLabel, onPaste, onSelect }: ListFieldTypeCommandProps): import("react").JSX.Element;
   export {};
   
 }
@@ -15018,19 +15401,20 @@ declare module 'alinea/field/metadata/MetadataField' {
       fields: Type<MetadataFields>;
       seo: Type<MetadataSeoFields>;
       details: Type<MetadataDetailsFields>;
-      /** The details are rendered by a separate `metadataDetails` section */
-      detailsSection?: boolean;
+      /** The details and previews are rendered by the separate
+       * `metadataDetails` and `metadataPreviews` sections */
+      sections?: boolean;
   }
   export interface MetadataConfig {
-      /** Leave the details out of the field view, render them with
-       * `metadataDetails(field)` instead */
-      detailsSection?: boolean;
+      /** Leave the details and previews out of the field view, render them
+       * with `metadataDetails(field)` and `metadataPreviews()` instead */
+      sections?: boolean;
   }
   export class MetadataField extends RecordField<Metadata, MetadataOptions> {
   }
   export interface MetadataField extends MetadataFields {
   }
-  export function metadata(label?: string, { detailsSection }?: MetadataConfig): MetadataField;
+  export function metadata(label?: string, { sections }?: MetadataConfig): MetadataField;
   export class MetadataDetailsSection implements SectionData {
       field: MetadataField;
       view: string;
@@ -15040,8 +15424,17 @@ declare module 'alinea/field/metadata/MetadataField' {
       constructor(field: MetadataField);
   }
   /** Renders the created/updated details and aliases of a metadata field
-   * created with `detailsSection: true` */
+   * created with `sections: true` */
   export function metadataDetails(field: MetadataField): Section;
+  export class MetadataPreviewsSection implements SectionData {
+      view: string;
+      definition: {};
+      fields: {};
+      sections: never[];
+  }
+  /** Renders the search and Open Graph previews of the entry, for a metadata
+   * field created with `sections: true` */
+  export function metadataPreviews(): Section;
   
 }
 
@@ -15061,6 +15454,7 @@ declare module 'alinea/field/metadata/MetadataField.view' {
   }
   export function MetadataUserFieldView({ field }: MetadataUserFieldViewProps): import("react").JSX.Element;
   export function MetadataFieldView({ field }: MetadataFieldViewProps): import("react").JSX.Element;
+  export function MetadataPreviewsView(): import("react").JSX.Element;
   export interface MetadataDetailsViewProps {
       section: Section;
   }
@@ -15390,8 +15784,10 @@ declare module 'alinea/field/richtext/RichTextBlock' {
       readOnly: boolean;
       onDelete: () => void;
       onDuplicate: () => void;
+      /** Called as the header starts a drag, before the editor handles it */
+      onDragStart: () => void;
   }
-  export const RichTextBlock: import("react").MemoExoticComponent<({ id, node, type, readOnly, onDelete, onDuplicate }: RichTextBlockProps) => import("react").JSX.Element>;
+  export const RichTextBlock: import("react").MemoExoticComponent<({ id, node, type, readOnly, onDelete, onDuplicate, onDragStart }: RichTextBlockProps) => import("react").JSX.Element>;
   
 }