alinea 2.0.0-preview.7 → 2.0.0-preview.8

package/dist/bundled.d.ts

@@ -44,28 +44,42 @@ declare module 'alinea/adapter/next/cms' {
   import { CMS } from 'alinea/core/CMS';
   import { Config } from 'alinea/core/Config';
   import type { UploadResponse } from 'alinea/core/Connection';
-  import { LocalDB } from 'alinea/core/db/LocalDB';
+  import type { LocalStore } from 'alinea/core/db/LocalStore';
   import type { Mutation } from 'alinea/core/db/Mutation';
   import type { GraphQuery } from 'alinea/core/Graph';
   import type { User } from 'alinea/core/User';
   import PLazy from 'p-lazy';
+  import type { DatabaseOptions } from 'rado';
   export interface PreviewProps {
       widget?: boolean;
+      /** Show the queries and syncs of each draft render in the widget */
+      stats?: boolean;
       workspace?: string;
       root?: string;
   }
+  export type OpenBundledDatabase = (config: Config, options?: DatabaseOptions) => Promise<LocalStore>;
+  export interface SyncStatus {
+      /** Whether queries are answered from the bundled database or the handler. */
+      source: 'database' | 'handler';
+      /** The content revision the answering side is at. */
+      sha: string | undefined;
+      /** When this isolate last synced its bundled database with the handler. */
+      syncedAt: Date | undefined;
+  }
   export class NextCMS<Definition extends Config = Config> extends CMS<Definition> {
       #private;
-      constructor(config: Definition);
+      bundledDb: PLazy<LocalStore>;
+      constructor(config: Definition, openBundledDatabase?: OpenBundledDatabase);
       throttle: (sync: () => Promise<unknown>, interval?: number) => Promise<void>;
-      bundledDb: PLazy<LocalDB>;
+      /** Where queries are answered from and how fresh that side is. */
+      status(): Promise<SyncStatus>;
       resolve<Query extends GraphQuery>(query: Query): Promise<any>;
       user(): Promise<User | undefined>;
       mutate(mutations: Array<Mutation>): Promise<{
           sha: string;
       }>;
       prepareUpload(file: string): Promise<UploadResponse>;
-      previews: ({ widget, workspace, root }: PreviewProps) => Promise<import("react").JSX.Element | null>;
+      previews: ({ widget, stats: showStats, workspace, root }: PreviewProps) => Promise<import("react").JSX.Element | null>;
   }
   export function createCMS<Definition extends Config>(config: Definition): NextCMS<Definition>;
   
@@ -98,27 +112,44 @@ declare module 'alinea/adapter/next/handler' {
   import { type BackendFactory, type BackendOptions } from 'alinea/backend/api/CreateBackend';
   import { type HandlerHooks } from 'alinea/backend/Handler';
   import { Config } from 'alinea/core/Config';
+  import type { LocalStore } from 'alinea/core/db/LocalStore';
   import { NextCMS } from 'alinea/adapter/next/cms';
   type Handler = (request: Request) => Promise<Response>;
   export interface NextHandlerOptions extends HandlerHooks {
       cms: NextCMS;
       backend?: BackendFactory | BackendOptions;
   }
-  export function createHandler(input: NextCMS | NextHandlerOptions): Handler;
+  export type OpenGeneratedDatabase = (config: Config) => Promise<LocalStore>;
+  export function createHandlerWithDatabase(input: NextCMS | NextHandlerOptions, openGeneratedDatabase?: OpenGeneratedDatabase): Handler;
   export function handlerPathname(config: Config, requestUrl: URL): string;
+  /** A handler without a generated database, as used in the Edge runtime. */
+  export function createHandler(input: NextCMS | NextHandlerOptions): Handler;
   export {};
   
 }
 
+declare module 'alinea/adapter/next/node' {
+
+  import type { Config } from 'alinea/core/Config';
+  import { NextCMS } from 'alinea/adapter/next/cms';
+  import { type NextHandlerOptions } from 'alinea/adapter/next/handler';
+  export function createCMS<Definition extends Config>(config: Definition): NextCMS<Definition>;
+  export function createHandler(input: NextCMS | NextHandlerOptions): (request: Request) => Promise<Response>;
+  
+}
+
 declare module 'alinea/adapter/next/previews' {
 
+  import { type PreviewStats } from 'alinea/preview/widget';
   export interface NextPreviewsProps {
       dashboardUrl: string;
       widget?: boolean;
+      /** Resolves once the render's CMS queries settled. */
+      stats?: Promise<PreviewStats>;
       root?: string;
       workspace?: string;
   }
-  export default function NextPreviews({ dashboardUrl, widget, root, workspace }: NextPreviewsProps): import("react").JSX.Element | null;
+  export default function NextPreviews({ dashboardUrl, widget, stats, root, workspace }: NextPreviewsProps): import("react").JSX.Element | null;
   /**
    * Wrapper around `router.refresh()` from `next/navigation` `useRouter()` to return Promise, and resolve after refresh completed
    * @returns Refresh function
@@ -133,10 +164,44 @@ declare module 'alinea/adapter/next/previews.spec' {
   
 }
 
+declare module 'alinea/adapter/next/renderStats' {
+
+  import type { GraphQuery } from 'alinea/core/Graph';
+  import type { PreviewStat, PreviewStats } from 'alinea/preview/widget';
+  /** Collects the CMS queries and syncs of one draft render. */
+  export class RenderStats {
+      #private;
+      rows: Array<PreviewStat>;
+      statements: number;
+      sqlMs: number;
+      /** Add a row and count it as pending until `run` settles; see `timed`. */
+      track<T>(stat: Omit<PreviewStat, 'durationMs'>, run: (row: PreviewStat) => Promise<T>): Promise<T>;
+      statement(durationMs: number): void;
+      /**
+       * Resolves once nothing ran for `quietMs`, so queries of server components
+       * that render after the caller are counted, or after `maxMs` regardless.
+       */
+      settled(quietMs?: number, maxMs?: number): Promise<PreviewStats>;
+  }
+  /**
+   * Time the work a row stands for, such as answering a query without the sync
+   * it waited for.
+   */
+  export function timed<T>(row: PreviewStat | undefined, run: () => Promise<T>): Promise<T>;
+  /** A short description such as `first(type, url=/about)`. */
+  export function summarizeQuery(query: GraphQuery): string;
+  
+}
+
 declare module 'alinea/adapter/next/syncCheck' {
 
   import type { Client } from 'alinea/core/Client';
-  import type { LocalDB } from 'alinea/core/db/LocalDB';
+  import type { SyncOptions } from 'alinea/core/db/LocalStore';
+  import type { RemoteSource } from 'alinea/core/source/Source';
+  interface SyncableDB {
+      readonly sha: string | Promise<string>;
+      syncWith(source: RemoteSource, options?: SyncOptions): Promise<string>;
+  }
   export const CONTENT_SHA_TAG = "alinea-content-sha";
   export function revalidateContentSha(): Promise<void>;
   /**
@@ -146,7 +211,8 @@ declare module 'alinea/adapter/next/syncCheck' {
    * Returns false when the sha could not be determined, so the caller falls
    * back to its existing throttle behavior.
    */
-  export function syncIfStale(db: LocalDB, client: Client, syncInterval?: number): Promise<boolean>;
+  export function syncIfStale(db: SyncableDB, client: Client, syncInterval?: number, options?: SyncOptions): Promise<boolean>;
+  export {};
   
 }
 
@@ -506,7 +572,7 @@ declare module 'alinea/backend/Handler' {
 
   import type { CMS } from 'alinea/core/CMS';
   import type { AuthedContext, RemoteConnection, RequestContext } from 'alinea/core/Connection';
-  import { LocalDB } from 'alinea/core/db/LocalDB';
+  import type { LocalStore } from 'alinea/core/db/LocalStore';
   import type { Mutation } from 'alinea/core/db/Mutation';
   export interface Handler {
       (request: Request, context: RequestContext): Promise<Response>;
@@ -524,7 +590,7 @@ declare module 'alinea/backend/Handler' {
   }
   export interface HandlerOptions extends HandlerHooks {
       cms: CMS;
-      db: LocalDB | Promise<LocalDB>;
+      db: LocalStore | Promise<LocalStore>;
       remote?: (context: RequestContext) => RemoteConnection;
       forwardMutations?(request: Request, context: AuthedContext): Promise<Response | undefined>;
   }
@@ -562,15 +628,15 @@ declare module 'alinea/backend/Previews' {
 
 declare module 'alinea/backend/resolver/ParsePreview' {
 
-  import type { LocalDB } from 'alinea/core/db/LocalDB';
   import { Entry } from 'alinea/core/Entry';
   import type { PreviewRequest, PreviewUpdate } from 'alinea/core/Preview';
+  import type { Graph } from 'alinea/core/Graph';
   export interface DecodedEntryPreview {
       entry: Entry;
   }
   export type DecodedPreviewRequest = PreviewUpdate | DecodedEntryPreview;
   export function decodePreviewRequest(preview: PreviewRequest): Promise<DecodedPreviewRequest>;
-  export function applyPreview(local: LocalDB, preview: DecodedPreviewRequest): Promise<PreviewRequest | undefined>;
+  export function applyPreview(local: Graph, preview: DecodedPreviewRequest): Promise<PreviewRequest | undefined>;
   
 }
 
@@ -737,16 +803,28 @@ declare module 'alinea/backend/router/Router' {
   
 }
 
-declare module 'alinea/backend/store/GeneratedRelease' {
+declare module 'alinea/backend/store/GeneratedDatabase' {
 
-  export const generatedRelease: Promise<string>;
+  import type { Config } from 'alinea/core/Config';
+  import { EntryStore } from 'alinea/database/EntryStore';
+  import type { Database } from 'rado';
+  /** Add one writable, connection-local layer over a generated database. */
+  export function createGeneratedDatabase(config: Config, db: Database): Promise<EntryStore>;
   
 }
 
-declare module 'alinea/backend/store/GeneratedSource' {
+declare module 'alinea/backend/store/GeneratedDatabaseNode' {
 
-  import { MemorySource } from 'alinea/core/source/MemorySource';
-  export const generatedSource: Promise<MemorySource>;
+  import type { Config } from 'alinea/core/Config';
+  import type { DatabaseOptions } from 'rado';
+  /** Open the traced generated file through the native SQLite driver. */
+  export function generatedDatabase(config: Config, options?: DatabaseOptions): Promise<import("alinea/database/EntryStore").EntryStore>;
+  
+}
+
+declare module 'alinea/backend/store/GeneratedRelease' {
+
+  export const generatedRelease: Promise<string>;
   
 }
 
@@ -872,23 +950,40 @@ declare module 'alinea/cli/generate/DevDB' {
 
   import { Config } from 'alinea/core/Config';
   import type { UploadResponse } from 'alinea/core/Connection';
-  import type { CommitRequest } from 'alinea/core/db/CommitRequest';
-  import { LocalDB } from 'alinea/core/db/LocalDB';
+  import { type CommitRequest } from 'alinea/core/db/CommitRequest';
   import { CachedFSSource } from 'alinea/core/source/FSSource';
+  import { EntryDatabase } from 'alinea/database/EntryDatabase';
+  import { EntryStore } from 'alinea/database/EntryStore';
   export interface DevDBOptions {
       config: Config;
       rootDir: string;
+      databasePath: string;
+      configFingerprint?: string;
       dashboardUrl: string | undefined;
   }
   export interface WatchFiles {
       files: Array<string>;
       dirs: Array<string>;
   }
-  export class DevDB extends LocalDB {
+  /** The persistent generated database used by dev, build and the local handler. */
+  export class DevDB extends EntryStore {
       #private;
-      source: CachedFSSource;
-      constructor(options: DevDBOptions);
+      readonly source: CachedFSSource;
+      readonly database: EntryDatabase;
+      private constructor();
+      /** Whether the source was restored from a previously built database. */
+      get hydrated(): boolean;
+      /** How many entries the last sync changed; zero when everything was reused. */
+      get lastSyncChanges(): number;
+      static create(options: DevDBOptions): Promise<DevDB>;
+      /**
+       * Adopt a changed config in place: every entry is derived again from the
+       * content files while the database stays open, so the dev server keeps
+       * serving through the rebuild and the hydrated file stats stay valid.
+       */
+      reconfigure(options: Pick<DevDBOptions, 'config' | 'configFingerprint' | 'dashboardUrl'>): Promise<void>;
       sync(): Promise<string>;
+      finalize(): Promise<number>;
       fix(): Promise<void>;
       watchFiles(): Promise<WatchFiles>;
       isInMediaLocation(file: string): boolean;
@@ -1032,7 +1127,7 @@ declare module 'alinea/cli/serve/LiveReload' {
   export class LiveReload {
       clients: Array<Client>;
       reload(type: 'refetch' | 'refresh' | 'reload'): void;
-      register(client: Client): void;
+      register(client: Client): () => void;
   }
   export {};
   
@@ -2027,11 +2122,12 @@ declare module 'alinea/components/Tooltip' {
 
 declare module 'alinea/components/Tree' {
 
-  import { type ReactNode } from 'react';
+  import { type ReactNode, type Ref } from 'react';
   import { type TreeItemContentProps as AriaTreeItemContentProps, type TreeItemProps as AriaTreeItemProps, type TreeProps as AriaTreeProps } from 'react-aria-components';
   import { type IconProps } from 'alinea/components/Icon';
   export interface TreeProps<T extends object> extends Omit<AriaTreeProps<T>, 'className'> {
       className?: string;
+      ref?: Ref<HTMLDivElement>;
   }
   export function Tree<T extends object>(props: TreeProps<T>): import("react").JSX.Element;
   export interface TreeItemContentProps extends Omit<AriaTreeItemContentProps, 'children'> {
@@ -2394,178 +2490,6 @@ declare module 'alinea/core/db/EntryAliases' {
   
 }
 
-declare module 'alinea/core/db/EntryDB' {
-
-  import type { Config } from 'alinea/core/Config';
-  import type { LocalConnection, UploadMetadata, UploadResponse } from 'alinea/core/Connection';
-  import type { Source } from 'alinea/core/source/Source';
-  import { type CommitRequest } from 'alinea/core/db/CommitRequest';
-  import { LocalDB } from 'alinea/core/db/LocalDB';
-  import type { Mutation } from 'alinea/core/db/Mutation';
-  export class EntryDB extends LocalDB {
-      connect: () => Promise<LocalConnection>;
-      constructor(config: Config, source: Source, connect: () => Promise<LocalConnection>);
-      mutate(mutations: Array<Mutation>): Promise<{
-          sha: string;
-          remote: Promise<string>;
-      }>;
-      write(request: CommitRequest): Promise<{
-          sha: string;
-      }>;
-      prepareUpload(file: string, metadata?: UploadMetadata): Promise<UploadResponse>;
-      syncWithRemote(): Promise<string>;
-  }
-  
-}
-
-declare module 'alinea/core/db/EntryIndex' {
-
-  import { Config } from 'alinea/core/Config';
-  import type { Entry, EntryStatus } from 'alinea/core/Entry';
-  import type { ChangesBatch } from 'alinea/core/source/Change';
-  import { type Source } from 'alinea/core/source/Source';
-  import { ReadonlyTree } from 'alinea/core/source/Tree';
-  import { Type } from 'alinea/core/Type';
-  import type { EntryReferenceQuery, EntryReferenceResult } from 'alinea/core/db/EntryReference';
-  import { EntryReferenceIndex } from 'alinea/core/db/EntryReferenceIndex';
-  import { EntryTransaction } from 'alinea/core/db/EntryTransaction';
-  export interface EntryFilter {
-      ids?: ReadonlyArray<string>;
-      search?: string;
-      condition?(entry: Entry): boolean;
-  }
-  export interface EntryCondition {
-      search?: string;
-      nodes?: Iterable<EntryNode>;
-      node?(node: EntryNode): boolean;
-      language?(language: EntryLanguageNode): boolean;
-      entry?(entry: Entry): boolean;
-  }
-  interface EntryNodeQuery {
-      ids?: ReadonlyArray<string>;
-      parentIds?: ReadonlyArray<string | null>;
-      urls?: ReadonlyArray<string>;
-      workspaces?: ReadonlyArray<string>;
-      roots?: ReadonlyArray<string>;
-      types?: ReadonlyArray<string>;
-  }
-  export function combineConditions(a: EntryCondition, b: EntryCondition): EntryCondition;
-  interface EntryVersionData {
-      id: string;
-      type: string;
-      index: string;
-      searchableText?: string;
-      title: string;
-      data: Record<string, unknown>;
-      seeded: string | null;
-      rowHash: string;
-      fileHash: string;
-  }
-  interface EntryVersion extends EntryVersionData {
-      locale: string | null;
-      workspace: string;
-      root: string;
-      path: string;
-      status: EntryStatus;
-      parentDir: string;
-      childrenDir: string;
-      filePath: string;
-      level: number;
-  }
-  class EntryLanguage extends Map<EntryStatus, EntryVersion> {
-      readonly locale: string | null;
-      readonly parentDir: string;
-      readonly selfDir: string;
-      constructor(versions: Array<EntryVersion>);
-  }
-  class EntryCollection extends Map<string | null, EntryLanguage> {
-      versions: Array<EntryVersion>;
-      readonly type: string;
-      constructor(versions: Array<EntryVersion>);
-  }
-  class EntryLanguageNode {
-      #private;
-      private node;
-      private language;
-      inheritedStatus: EntryStatus | undefined;
-      main: EntryVersion;
-      active: EntryVersion;
-      url: string;
-      locale: string | null;
-      path: string;
-      readonly seeded: string | null;
-      constructor(node: EntryNode, language: EntryLanguage);
-      [Symbol.iterator](): MapIterator<[EntryStatus, EntryVersion]>;
-      has(status: EntryStatus): boolean;
-      get parentPaths(): string[];
-      get entries(): Entry<Record<string, unknown>>[];
-      filter(filter: EntryCondition): Generator<Entry>;
-  }
-  export class EntryNode extends Map<string | null, EntryLanguageNode> {
-      graph: EntryGraph;
-      entryType: Type;
-      parent: EntryNode | null;
-      children: () => Iterable<EntryNode>;
-      readonly id: string;
-      readonly index: string;
-      readonly parentId: string | null;
-      readonly parents: Array<string>;
-      readonly workspace: string;
-      readonly root: string;
-      readonly type: string;
-      readonly level: number;
-      constructor(graph: EntryGraph, entryType: Type, parent: EntryNode | null, children: () => Iterable<EntryNode>, collection: EntryCollection);
-      filter(filter: EntryCondition): Generator<Entry>;
-  }
-  export class EntryGraph {
-      #private;
-      nodes: Array<EntryNode>;
-      constructor(config: Config, versionData: Map<string, EntryVersionData>, seeds: Map<string, Seed>);
-      byId(id: string): EntryNode | undefined;
-      candidateNodes(query: EntryNodeQuery): Array<EntryNode> | undefined;
-      byUrl(url: string): Iterable<Entry>;
-      byAlias(alias: string): Iterable<Entry>;
-      get config(): Config;
-      byDir(dir: string): EntryNode | undefined;
-      entryByFilePath(filePath: string): Entry | undefined;
-      withChanges(batch: ChangesBatch): EntryGraph;
-      filter({ search, ...filter }: EntryCondition): Generator<Entry>;
-  }
-  export class EntryIndex extends EventTarget {
-      #private;
-      tree: ReadonlyTree;
-      initialSync: ReadonlyTree | undefined;
-      graph: EntryGraph;
-      constructor(config: Config);
-      clone(): EntryIndex;
-      get sha(): string;
-      filter(filter: EntryCondition): Iterable<Entry>;
-      findFirst<T extends Record<string, unknown>>(filter: (entry: Entry) => boolean): Entry<T> | undefined;
-      findMany(filter: (entry: Entry) => boolean): Iterable<Entry>;
-      findByUrl(url: string, filter: (entry: Entry) => boolean): Entry | undefined;
-      referencesTo(query: EntryReferenceQuery): Promise<EntryReferenceResult>;
-      referencesFrom(sourceId: string): Promise<import("alinea/core/db/EntryReference").EntryReference[]>;
-      get references(): Promise<EntryReferenceIndex>;
-      sync(source: Source): Promise<string>;
-      syncWith(source: Source): Promise<string>;
-      indexChanges(batch: ChangesBatch, targetTree?: ReadonlyTree): Promise<string>;
-      seed(source: Source): Promise<void>;
-      byId(id: string): EntryNode | undefined;
-      fix(source: Source): Promise<void>;
-      transaction(source: Source): Promise<EntryTransaction>;
-  }
-  interface Seed {
-      seedId: string;
-      type: string;
-      workspace: string;
-      root: string;
-      locale: string | null;
-      data: Record<string, any>;
-  }
-  export {};
-  
-}
-
 declare module 'alinea/core/db/EntryReference' {
 
   import type { EntryStatus } from 'alinea/core/Entry';
@@ -2600,151 +2524,12 @@ declare module 'alinea/core/db/EntryReference' {
   export interface EntryReferenceResult {
       references: Array<EntryReference>;
       total: number;
-      scan: EntryReferenceScan;
   }
   export interface FieldReferenceContext {
       path: Array<string>;
       label?: string;
   }
   export function referenceFieldPath(path: Array<string>): string;
-  export interface EntryReferenceScan {
-      scanned: number;
-      total: number;
-      complete: boolean;
-  }
-  
-}
-
-declare module 'alinea/core/db/EntryReferenceIndex' {
-
-  import type { Config } from 'alinea/core/Config';
-  import type { EntryCondition } from 'alinea/core/db/EntryIndex';
-  import { type EntryReference, type EntryReferenceQuery, type EntryReferenceResult, type EntryReferenceScan } from 'alinea/core/db/EntryReference';
-  import type { Entry } from 'alinea/core/Entry';
-  export interface EntryReferenceGraph {
-      config: Config;
-      filter(filter: EntryCondition): Iterable<Entry>;
-  }
-  export interface EntryReferenceBuildOptions {
-      onProgress?: (scan: EntryReferenceScan) => void;
-  }
-  export class EntryReferenceIndex {
-      #private;
-      static build(graph: EntryReferenceGraph, options?: EntryReferenceBuildOptions): Promise<EntryReferenceIndex>;
-      constructor(config: Config);
-      referencesTo(query: EntryReferenceQuery): EntryReferenceResult;
-      referencesFrom(sourceId: string): Array<EntryReference>;
-      replaceEntry(entry: Entry): Set<string>;
-      removeFile(filePath: string): Set<string>;
-      replaceFile(filePath: string, references: Array<EntryReference>): Set<string>;
-  }
-  
-}
-
-declare module 'alinea/core/db/EntryResolver' {
-
-  import type { Config } from 'alinea/core/Config';
-  import { Entry as EntryExprs, type Entry } from 'alinea/core/Entry';
-  import type { Expr } from 'alinea/core/Expr';
-  import { Field } from 'alinea/core/Field';
-  import type { Filter } from 'alinea/core/Filter';
-  import { type AnyQueryResult, type Edge, type EdgeQuery, type GraphQuery, type Projection, type Status } from 'alinea/core/Graph';
-  import { type HasExpr } from 'alinea/core/Internal';
-  import type { Resolver } from 'alinea/core/Resolver';
-  import type { Type } from 'alinea';
-  import { type EntryCondition, type EntryFilter, type EntryGraph, type EntryIndex } from 'alinea/core/db/EntryIndex';
-  import { LinkResolver } from 'alinea/core/db/LinkResolver';
-  type Interim = any;
-  export interface PostContext {
-      linkResolver: LinkResolver;
-  }
-  export class EntryResolver implements Resolver {
-      #private;
-      config: Config;
-      index: EntryIndex;
-      constructor(config: Config, index: EntryIndex);
-      call(ctx: ResolveContext, entry: Entry, internal: {
-          method: string;
-          args: Array<Expr>;
-      }): unknown;
-      field(entry: Entry, field: Expr): unknown;
-      expr(ctx: ResolveContext, entry: Entry, expr: Expr): unknown;
-      projectTypes(types: Array<Type>): Array<[string, Expr]>;
-      projection(query: GraphQuery<Projection>): Projection;
-      sourceFilter(ctx: ResolveContext, entry: Entry, query: EdgeQuery): EntryCondition;
-      selectProjection(ctx: ResolveContext, entry: Entry, value: Projection): unknown;
-      select(ctx: ResolveContext, entry: Entry | null, query: GraphQuery<Projection>): unknown;
-      condition(ctx: ResolveContext, query: EdgeQuery): EntryFilter;
-      isSingleResult(query: GraphQuery & Partial<Edge>): boolean;
-      query(ctx: ResolveContext, query: GraphQuery<Projection>, preFilter?: EntryCondition): {
-          entries: EntryExprs<Record<string, unknown>>[];
-          getUnprocessed: () => unknown;
-          getProcessed: () => Promise<any>;
-      };
-      postField(ctx: PostContext, interim: Interim, field: Field): Promise<unknown>;
-      postExpr(ctx: PostContext, interim: Interim, expr: HasExpr): Promise<unknown>;
-      postRow(ctx: PostContext, interim: Interim, query: GraphQuery<Projection>): Promise<unknown>;
-      post(ctx: PostContext, interim: Interim, input: EdgeQuery<Projection>): Promise<unknown>;
-      resolve<Query extends GraphQuery>(query: Query): Promise<AnyQueryResult<Query>>;
-  }
-  export interface ResolveContext {
-      status: Status;
-      locale?: string | null;
-      graph: EntryGraph;
-      searchTerms?: string;
-  }
-  export function statusChecker(status: Status): Check;
-  interface Check {
-      (input: Entry): boolean;
-  }
-  export function filterChecker(filter: Filter, getField?: (input: any, name: string) => any): Check;
-  export {};
-  
-}
-
-declare module 'alinea/core/db/EntryTarget' {
-
-  import type { RemoteSource } from 'alinea/core/source/Source';
-  import type { CommitRequest } from 'alinea/core/db/CommitRequest';
-  export interface EntryTarget extends RemoteSource {
-      commit(request: CommitRequest): Promise<string>;
-  }
-  
-}
-
-declare module 'alinea/core/db/EntryTransaction' {
-
-  import { Config } from 'alinea/core/Config';
-  import { Policy } from 'alinea/core/Role';
-  import type { Source } from 'alinea/core/source/Source';
-  import type { ReadonlyTree } from 'alinea/core/source/Tree';
-  import { type CommitChange } from 'alinea/core/db/CommitRequest';
-  import type { EntryIndex } from 'alinea/core/db/EntryIndex';
-  import type { ArchiveMutation, CreateMutation, MoveMutation, Mutation, PublishMutation, RemoveFileMutation, RemoveMutation, UnpublishMutation, UpdateMutation, UploadFileMutation } from 'alinea/core/db/Mutation';
-  type Op<T> = Omit<T, 'op'>;
-  export class EntryTransaction {
-      #private;
-      constructor(config: Config, index: EntryIndex, source: Source, from: ReadonlyTree, policy?: Policy);
-      get empty(): boolean;
-      create({ locale, type, data, root, workspace, fromSeed, parentId, id, insertOrder, status, overwrite }: Op<CreateMutation>): this;
-      update({ id, locale, status, set }: Op<UpdateMutation>): this;
-      publish({ id, locale, status }: Op<PublishMutation>): this;
-      unpublish({ id, locale }: Op<UnpublishMutation>): this;
-      archive({ id, locale }: Op<ArchiveMutation>): this;
-      move({ id, target, dropPosition, targetType }: Op<MoveMutation>): this;
-      remove({ id, locale, status }: Op<RemoveMutation>): this;
-      removeFile(mutation: Op<RemoveFileMutation>): this;
-      uploadFile(mutation: Op<UploadFileMutation>): this;
-      description(): string;
-      apply(mutations: ReadonlyArray<Mutation>): Promise<void>;
-      toRequest(): Promise<{
-          fromSha: string;
-          intoSha: string;
-          description: string;
-          changes: CommitChange[];
-      }>;
-  }
-  export {};
   
 }
 
@@ -2767,8 +2552,9 @@ declare module 'alinea/core/db/EntryUrlConflictError' {
 declare module 'alinea/core/db/IndexEvent' {
 
   export class IndexEvent extends Event {
-      data: IndexOp;
       static readonly type = "index";
+      static [Symbol.hasInstance](value: unknown): boolean;
+      data: IndexOp;
       constructor(data: IndexOp);
   }
   export type IndexOp = {
@@ -2792,17 +2578,17 @@ declare module 'alinea/core/db/IndexEvent' {
 declare module 'alinea/core/db/LinkResolver' {
 
   import type { InferProjection, Projection } from 'alinea/core/Graph';
-  import type { EntryResolver, ResolveContext } from 'alinea/core/db/EntryResolver';
+  import type { Config } from 'alinea/core/Config';
   export interface LinkTarget {
       entryId: string;
       locale?: string;
   }
-  export class LinkResolver {
-      resolver: EntryResolver;
-      private ctx;
+  /** Field postprocessors depend on query capabilities, not an index backend. */
+  export interface LinkResolver {
+      config: Config;
       locale: string | null;
-      constructor(resolver: EntryResolver, ctx: ResolveContext, locale: string | null);
-      resolveLinks<P extends Projection>(projection: P, entryIds: ReadonlyArray<string>, locale?: string | null | undefined): Promise<Array<InferProjection<P>>>;
+      includedAtBuild(filePath: string): boolean | Promise<boolean>;
+      resolveLinks<P extends Projection>(projection: P, entryIds: ReadonlyArray<string>, locale?: string | null): Promise<Array<InferProjection<P>>>;
       resolveTargets<P extends Projection & {
           id: unknown;
       }>(projection: P, targets: ReadonlyArray<LinkTarget>): Promise<Array<InferProjection<P> | undefined>>;
@@ -2810,49 +2596,32 @@ declare module 'alinea/core/db/LinkResolver' {
   
 }
 
-declare module 'alinea/core/db/LocalDB' {
+declare module 'alinea/core/db/LocalStore' {
 
-  import type { Config } from 'alinea/core/Config';
-  import type { SyncApi, UploadMetadata, UploadResponse } from 'alinea/core/Connection';
-  import type { AnyQueryResult, GraphQuery } from 'alinea/core/Graph';
   import type { Policy } from 'alinea/core/Role';
-  import type { ChangesBatch } from 'alinea/core/source/Change';
-  import type { GetBlobsOptions } from 'alinea/core/source/Source';
-  import { type Source } from 'alinea/core/source/Source';
-  import { type CommitRequest } from 'alinea/core/db/CommitRequest';
-  import { EntryIndex } from 'alinea/core/db/EntryIndex';
-  import type { EntryReferenceQuery, EntryReferenceResult } from 'alinea/core/db/EntryReference';
+  import type { RemoteSource, Source } from 'alinea/core/source/Source';
+  import type { CommitRequest } from 'alinea/core/db/CommitRequest';
   import type { Mutation } from 'alinea/core/db/Mutation';
-  import { WriteableGraph } from 'alinea/core/db/WriteableGraph';
-  export class LocalDB extends WriteableGraph {
-      #private;
-      config: Config;
-      index: EntryIndex;
+  import type { WriteableGraph } from 'alinea/core/db/WriteableGraph';
+  export interface SyncOptions {
+      /** Skip entry validation for a remote whose entries were already validated. */
+      validate?: boolean;
+  }
+  /**
+   * A locally available entry store: a writeable graph backed by a source that
+   * can be synced against a remote and committed to. Implemented by the SQLite
+   * engine (`EntryStore`) and the `LocalDB` convenience facade.
+   */
+  export interface LocalStore extends WriteableGraph, RemoteSource {
       source: Source;
-      constructor(config: Config, source?: Source, index?: EntryIndex);
-      resolve<Query extends GraphQuery>(query: Query): Promise<AnyQueryResult<Query>>;
-      referencesTo(query: EntryReferenceQuery): Promise<EntryReferenceResult>;
-      get sha(): string;
-      indexChanges(batch: ChangesBatch): Promise<string>;
-      applyChanges(batch: ChangesBatch): Promise<void>;
-      getTreeIfDifferent(sha: string): Promise<import("alinea/core/source/Tree").ReadonlyTree | undefined>;
-      getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncIterable<[sha: string, blob: Uint8Array<ArrayBufferLike>]>;
+      sha: string | Promise<string>;
       sync(): Promise<string>;
-      syncWith(remote: SyncApi): Promise<string>;
-      logEntries(): Promise<void>;
-      request(mutations: ReadonlyArray<Mutation>, policy?: Policy): Promise<{
-          fromSha: string;
-          intoSha: string;
-          description: string;
-          changes: import("alinea/core/db/CommitRequest").CommitChange[];
-      }>;
-      mutate(mutations: Array<Mutation>): Promise<{
-          sha: string;
-      }>;
+      syncWith(remote: RemoteSource, options?: SyncOptions): Promise<string>;
+      includedAtBuild(filePath: string): boolean | Promise<boolean>;
+      request(mutations: ReadonlyArray<Mutation>, policy?: Policy): Promise<CommitRequest>;
       write(request: CommitRequest): Promise<{
           sha: string;
       }>;
-      prepareUpload(file: string, _metadata?: UploadMetadata): Promise<UploadResponse>;
   }
   
 }
@@ -3034,30 +2803,6 @@ declare module 'alinea/core/db/Operation' {
   
 }
 
-declare module 'alinea/core/db/TestDB' {
-
-  import type { LocalConnection } from 'alinea/core/Connection';
-  import { type User, type UserInput } from 'alinea/core/User';
-  import { LocalDB } from 'alinea/core/db/LocalDB';
-  export class TestDB extends LocalDB implements LocalConnection {
-      capabilities(): Promise<{
-          users: boolean;
-      }>;
-      previewToken(): Promise<string>;
-      user(): Promise<User>;
-      enrichUser(user: User): Promise<User>;
-      listUsers(): Promise<Array<User>>;
-      createUser(user: UserInput): Promise<User>;
-      updateUser(user: UserInput): Promise<User>;
-      removeUser(): Promise<void>;
-      revisions(): Promise<never[]>;
-      revisionData(): Promise<undefined>;
-      getDraft(): Promise<undefined>;
-      storeDraft(): Promise<void>;
-  }
-  
-}
-
 declare module 'alinea/core/db/WriteableGraph' {
 
   import type { Infer } from 'alinea';
@@ -3174,6 +2919,8 @@ declare module 'alinea/core/Entry' {
   export const ALT_STATUS: Array<EntryStatus>;
   export interface Entry<Data extends object = Record<string, unknown>> {
       id: string;
+      /** Physical authored version before status inheritance is applied. */
+      versionStatus?: EntryStatus;
       status: EntryStatus;
       title: string;
       type: string;
@@ -3206,6 +2953,7 @@ declare module 'alinea/core/Entry' {
   }
   export const Entry: {
       id: Expr<string>;
+      versionStatus: Expr<EntryStatus>;
       status: Expr<EntryStatus>;
       title: Expr<string>;
       type: Expr<string>;
@@ -3328,6 +3076,30 @@ declare module 'alinea/core/EntryRecord' {
   
 }
 
+declare module 'alinea/core/EntrySeed' {
+
+  import { type Config as ConfigType } from 'alinea/core/Config';
+  import type { Mutation } from 'alinea/core/db/Mutation';
+  import type { Graph } from 'alinea/core/Graph';
+  export interface EntrySeed {
+      id: string;
+      type: string;
+      workspace: string;
+      root: string;
+      locale: string | null;
+      filePath: string;
+      nodePath: string;
+      parentNodePath: string | null;
+      seedPath: string;
+      data: Record<string, unknown>;
+  }
+  export function entrySeeds(config: ConfigType): ReadonlyArray<EntrySeed>;
+  /** Plan the creations needed to materialize every configured seed. */
+  export function seedMutations(graph: Graph, config: ConfigType): Promise<Array<Mutation>>;
+  export function seedData(config: ConfigType, seedPath: string | null, data: Record<string, unknown>, location: Pick<EntrySeed, 'workspace' | 'root' | 'locale'>): Record<string, unknown>;
+  
+}
+
 declare module 'alinea/core/Expr' {
 
   import { type HasExpr, internalExpr } from 'alinea/core/Internal';
@@ -3390,6 +3162,10 @@ declare module 'alinea/core/Field' {
   export interface FieldAnchorContext {
       anchors: Set<string>;
   }
+  export interface FieldLocalizeContext {
+      locale: string;
+      entryIds: Set<string>;
+  }
   export type WithoutLabel<Options extends FieldOptions<any>> = Omit<Options, 'label'>;
   export interface FieldMeta<StoredValue, QueryValue, Mutator, Options> {
       options: Options & FieldOptions<StoredValue>;
@@ -3404,6 +3180,8 @@ declare module 'alinea/core/Field' {
       references?: (value: StoredValue, context: FieldReferenceContext) => Array<EntryReferenceTarget>;
       anchors?: (value: StoredValue, context: FieldReferenceContext) => Array<EntryAnchorTarget>;
       normalizeAnchors?: (value: StoredValue, context: FieldAnchorContext) => StoredValue;
+      /** Point entry links to entryIds at the given locale */
+      localizeLinks?: (value: StoredValue, context: FieldLocalizeContext) => StoredValue;
       beforeSave?: (context: FieldBeforeSaveContext<StoredValue>) => StoredValue;
   }
   export type FieldBeforeSaveAction = 'create' | 'update' | 'publish' | 'translate';
@@ -3450,6 +3228,7 @@ declare module 'alinea/core/Field' {
       function references<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>, value: StoredValue, context: FieldReferenceContext): Array<EntryReferenceTarget>;
       function anchors<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>, value: StoredValue, context: FieldReferenceContext): Array<EntryAnchorTarget>;
       function normalizeAnchors<StoredValue>(field: HasField, value: StoredValue, context: FieldAnchorContext): StoredValue;
+      function localizeLinks<StoredValue>(field: HasField, value: StoredValue, context: FieldLocalizeContext): StoredValue;
       function isField(value: any): value is Field;
   }
   export {};
@@ -3619,8 +3398,6 @@ declare module 'alinea/core/Filter' {
   type FieldOps<Fields> = {
       [K in keyof Fields]?: Condition<Fields[K]>;
   };
-  export interface AnyCondition<Value> extends Ops<Value>, ArrayOps<Value>, ObjectOps<Value> {
-  }
   export type Condition<Value> = [Value] extends [Primitive] ? Ops<Value> | Value : [Value] extends [Array<any>] ? ArrayOps<Value[0]> : ObjectOps<Value>;
   type AndCondition<Fields> = {
       and: Array<Filter<Fields> | undefined>;
@@ -3629,6 +3406,46 @@ declare module 'alinea/core/Filter' {
       or: Array<Filter<Fields> | undefined>;
   };
   export type Filter<Fields = unknown> = AndCondition<Fields> | OrCondition<Fields> | FieldOps<Fields>;
+  /** A validated filter over named fields, shared by every filter backend. */
+  export type FilterNode = {
+      op: 'and';
+      nodes: Array<FilterNode>;
+  } | {
+      op: 'or';
+      nodes: Array<FilterNode>;
+  } | {
+      op: 'field';
+      name: string;
+      condition: ConditionNode;
+  };
+  /** A validated condition on one value. */
+  export type ConditionNode = {
+      op: 'and';
+      nodes: Array<ConditionNode>;
+  } | {
+      op: 'or';
+      nodes: Array<ConditionNode>;
+  } | {
+      op: 'is' | 'isNot' | 'gt' | 'gte' | 'lt' | 'lte';
+      value: unknown;
+  } | {
+      op: 'in' | 'notIn';
+      values: Array<unknown>;
+  } | {
+      op: 'startsWith';
+      value: string;
+  } | {
+      op: 'has';
+      filter: FilterNode;
+  } | {
+      op: 'includes';
+      item: ConditionNode;
+  };
+  export function parseFilter(filter: unknown): FilterNode;
+  export function parseCondition(condition: unknown): ConditionNode;
+  type FilterCheck<Input> = (input: Input) => boolean;
+  type FieldAccessor<Input> = (input: Input, name: string) => unknown;
+  export function filterChecker<Input = unknown>(filter: Filter, getField?: FieldAccessor<Input>): FilterCheck<Input>;
   export {};
   
 }
@@ -3637,6 +3454,7 @@ declare module 'alinea/core/Graph' {
 
   import type { Root, Workspace } from 'alinea/types';
   import type { Config } from 'alinea/core/Config';
+  import type { EntryStatus } from 'alinea/core/Entry';
   import type { EntryFields } from 'alinea/core/EntryFields';
   import type { Expr } from 'alinea/core/Expr';
   import type { Condition, Filter } from 'alinea/core/Filter';
@@ -3738,8 +3556,16 @@ declare module 'alinea/core/Graph' {
       id?: Condition<string>;
       /** Filter by parentId */
       parentId?: Condition<string | null>;
+      /** Filter by the physical authored status before inheritance. */
+      versionStatus?: Condition<EntryStatus>;
+      /** Filter by whether this is the preferred version for its locale. */
+      main?: Condition<boolean>;
       /** Filter by path */
       path?: Condition<string>;
+      /** Filter by the full source file path. */
+      filePath?: Condition<string>;
+      /** Filter by the configured seed identity. */
+      seeded?: Condition<string | null>;
       /** Filter by url */
       url?: Condition<string>;
       /** Filter by a metadata URL alias */
@@ -3969,6 +3795,7 @@ declare module 'alinea/core/ListRow' {
       const id = "_id";
       const index = "_index";
       const type = "_type";
+      const label = "_label";
   }
   
 }
@@ -4329,6 +4156,7 @@ declare module 'alinea/core/Reference' {
   export interface Reference {
       _id: string;
       _type: string;
+      _label?: string;
   }
   export namespace Reference {
       const id = "_id";
@@ -4592,6 +4420,8 @@ declare module 'alinea/core/Scope' {
       keyOf(entity: Entity): string;
       locationOf(entity: Entity): string[] | undefined;
       nameOf(entity: Entity): string | undefined;
+      /** Configured spellings of a locale, matched case-insensitively. */
+      locales(locale: string): Array<string>;
       stringify(input: any): string;
       parse<Result>(input: string): Result;
   }
@@ -4719,11 +4549,23 @@ declare module 'alinea/core/source/FSSource' {
   import type { ChangesBatch } from 'alinea/core/source/Change';
   import type { GetBlobsOptions, Source } from 'alinea/core/source/Source';
   import { ReadonlyTree, WriteableTree } from 'alinea/core/source/Tree';
+  /** The filesystem metadata used to detect that a file did not change. */
+  export interface FileStat {
+      mtimeMs: number;
+      size: number;
+  }
   export class FSSource implements Source {
       #private;
       constructor(cwd: string);
+      /**
+       * Restore a previously persisted tree and the file stats it was built from,
+       * so unchanged files are not read again.
+       */
+      hydrate(tree: ReadonlyTree, stats: ReadonlyMap<string, FileStat>): void;
+      /** The file stats of every file in the current tree. */
+      fileStats(): ReadonlyMap<string, FileStat>;
       getTree(): Promise<ReadonlyTree>;
-      getFile(current: ReadonlyTree, builder: WriteableTree, file: string): Promise<readonly [string, Uint8Array<ArrayBufferLike>] | undefined>;
+      getFile(current: ReadonlyTree, builder: WriteableTree, filePath: string): Promise<readonly [string, Uint8Array<ArrayBufferLike>] | undefined>;
       getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
       getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
       readBlob(sha: string, file: string, signal?: AbortSignal): Promise<[sha: string, blob: Uint8Array]>;
@@ -4732,7 +4574,7 @@ declare module 'alinea/core/source/FSSource' {
   export class CachedFSSource extends FSSource {
       #private;
       constructor(cwd: string);
-      refresh: () => Promise<ReadonlyTree>;
+      refresh(): Promise<ReadonlyTree>;
       getTree(): Promise<ReadonlyTree>;
       applyChanges(batch: ChangesBatch): Promise<void>;
       getFile(current: ReadonlyTree, builder: WriteableTree, file: string): Promise<readonly [string, Uint8Array<ArrayBufferLike>] | undefined>;
@@ -4790,6 +4632,10 @@ declare module 'alinea/core/source/GitUtils' {
    * Serializes a TreeData object into a Git tree object as a Uint8Array.
    */
   export function serializeTreeEntries(entries: Array<Entry>): Uint8Array;
+  /**
+   * Compares two TreeEntry objects for sorting.
+   */
+  export function compareTreeEntries(a: Entry, b: Entry): number;
   /**
    * Parses a Git tree object from a Uint8Array into a TreeEntry object.
    */
@@ -4812,7 +4658,7 @@ declare module 'alinea/core/source/GitUtils' {
 declare module 'alinea/core/source/IndexedDBSource' {
 
   import type { ChangesBatch } from 'alinea/core/source/Change';
-  import type { GetBlobsOptions, Source } from 'alinea/core/source/Source';
+  import type { GetBlobsOptions, RemoteSource, Source } from 'alinea/core/source/Source';
   import { ReadonlyTree } from 'alinea/core/source/Tree';
   export class IndexedDBSource implements Source {
       #private;
@@ -4821,6 +4667,7 @@ declare module 'alinea/core/source/IndexedDBSource' {
       getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
       getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
       applyChanges(batch: ChangesBatch): Promise<void>;
+      applyChangesFrom(remote: RemoteSource, batch: ChangesBatch, tree: ReadonlyTree): Promise<void>;
   }
   
 }
@@ -4845,8 +4692,8 @@ declare module 'alinea/core/source/MemorySource' {
 declare module 'alinea/core/source/OverlaySource' {
 
   import type { ChangesBatch } from 'alinea/core/source/Change';
-  import type { GetBlobsOptions, Source } from 'alinea/core/source/Source';
-  import type { ReadonlyTree } from 'alinea/core/source/Tree';
+  import type { GetBlobsOptions, RemoteSource, Source } from 'alinea/core/source/Source';
+  import { type ReadonlyTree } from 'alinea/core/source/Tree';
   export class OverlaySource implements Source {
       #private;
       constructor(source: Source, tree: ReadonlyTree);
@@ -4855,6 +4702,9 @@ declare module 'alinea/core/source/OverlaySource' {
       getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
       getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
       applyChanges(batch: ChangesBatch): Promise<void>;
+      applyChangesFrom(remote: RemoteSource, batch: ChangesBatch, tree: ReadonlyTree): Promise<void>;
+      /** Apply a batch while reusing an already received or compiled target tree. */
+      applyChangesTo(batch: ChangesBatch, tree?: ReadonlyTree): Promise<void>;
   }
   
 }
@@ -4884,7 +4734,10 @@ declare module 'alinea/core/source/Source' {
   export interface Source extends RemoteSource {
       getTree(): Promise<ReadonlyTree>;
       applyChanges(batch: ChangesBatch): Promise<void>;
+      /** Consume remote blobs incrementally instead of materializing one bundle. */
+      applyChangesFrom?(remote: RemoteSource, batch: ChangesBatch, tree: ReadonlyTree): Promise<void>;
   }
+  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>;
   export function syncWith(source: Source, remote: RemoteSource): Promise<ChangesBatch>;
@@ -4951,7 +4804,6 @@ declare module 'alinea/core/source/Tree' {
       readonly sha: string;
       readonly mode: string;
       constructor({ sha, mode }: BaseEntry);
-      clone(): Leaf;
       toJSON(): BaseEntry;
   }
   class TreeBase<Node extends TreeBase<Node>> {
@@ -4975,10 +4827,14 @@ declare module 'alinea/core/source/Tree' {
       readonly sha: string;
       static readonly EMPTY: ReadonlyTree;
       constructor({ sha, entries }: Tree);
+      /** A tree over built nodes, which it shares instead of copying. */
+      static fromNodes(nodes: Map<string, ReadonlyTree | Leaf>, sha?: string): Promise<ReadonlyTree>;
       get isEmpty(): boolean;
       get entries(): Array<Entry>;
-      get shas(): ReadonlySet<string>;
+      /** A path holding the blob, if this tree has it. */
+      pathOf(sha: string): string | undefined;
       hasSha(sha: string): boolean;
+      /** A writable tree sharing these nodes until they change. */
       clone(): WriteableTree;
       toJSON(): {
           sha: string;
@@ -4991,18 +4847,18 @@ declare module 'alinea/core/source/Tree' {
       };
       withChanges(batch: ChangesBatch): Promise<ReadonlyTree>;
       static fromFlat(tree: FlatTree): ReadonlyTree;
-      diff(that: TreeBase<any>): ChangesBatch;
+      diff(that: ReadonlyTree | WriteableTree): ChangesBatch;
   }
-  export class WriteableTree extends TreeBase<WriteableTree> {
+  /** A mutable tree, which copies shared readonly subtrees once they change. */
+  export class WriteableTree extends TreeBase<WriteableTree | ReadonlyTree> {
       #private;
       constructor({ sha, entries }?: Tree);
-      add(path: string, input: {
-          clone(): WriteableTree | Leaf;
-      } | string): void;
+      add(path: string, input: WriteableTree | ReadonlyTree | Leaf | string): void;
       remove(path: string): boolean;
       rename(from: string, to: string): void;
       applyChanges(batch: ChangesBatch): void;
       getSha(): Promise<string>;
+      /** Compile, reusing the nodes of a previous tree wherever they are equal. */
       compile(previous?: ReadonlyTree): Promise<ReadonlyTree>;
       clone(): WriteableTree;
   }
@@ -5159,7 +5015,7 @@ declare module 'alinea/core/Type' {
   import type { Config } from 'alinea/core/Config';
   import type { EntryStatus } from 'alinea/core/Entry';
   import type { Expr } from 'alinea/core/Expr';
-  import { Field, type EntryAnchorTarget, type FieldAnchorContext, type FieldBeforeSaveContext } from 'alinea/core/Field';
+  import { Field, type EntryAnchorTarget, type FieldAnchorContext, type FieldLocalizeContext, type FieldBeforeSaveContext } from 'alinea/core/Field';
   import { type HasType } from 'alinea/core/Internal';
   import type { Label } from 'alinea/core/Label';
   import type { OrderBy } from 'alinea/core/OrderBy';
@@ -5205,6 +5061,7 @@ declare module 'alinea/core/Type' {
       function initialValue(type: Type): Record<string, unknown>;
       function withInitialValue(type: Type, value: Record<string, unknown>): Record<string, unknown>;
       function normalizeAnchors(type: Type, value: Record<string, unknown>, context?: FieldAnchorContext): Record<string, unknown>;
+      function localizeLinks(type: Type, value: Record<string, unknown>, context: FieldLocalizeContext): Record<string, unknown>;
       function beforeSave(type: Type, value: Record<string, unknown>, context: Omit<FieldBeforeSaveContext<unknown>, 'value'>): Record<string, unknown>;
       function applyLinks(type: Type, value: Record<string, unknown>, loader: import('./db/LinkResolver.js').LinkResolver): Promise<void>;
       function preview(type: Type): Preview | undefined;
@@ -5306,6 +5163,12 @@ declare module 'alinea/core/util/ArrayBuffers' {
   
 }
 
+declare module 'alinea/core/util/Arrays' {
+
+  export function chunks<T>(items: ReadonlyArray<T>, size: number): Generator<Array<T>>;
+  
+}
+
 declare module 'alinea/core/util/Assert' {
 
   export function assert(value: unknown, message?: string): asserts value;
@@ -5324,7 +5187,14 @@ 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>;
-  
+  /** Run tasks one after another; a failed task does not block the next one. */
+  export class TaskQueue {
+      #private;
+      run<T>(task: () => Promise<T>): Promise<T>;
+      /** Resolve once every task queued so far has settled. */
+      drain(): Promise<void>;
+  }
+  
 }
 
 declare module 'alinea/core/util/BufferToBase64' {
@@ -5483,10 +5353,29 @@ declare module 'alinea/core/util/Encoding' {
 
 declare module 'alinea/core/util/EntryFilenames' {
 
-  import type { Config } from 'alinea/core/Config';
+  import { Config } from 'alinea/core/Config';
   import { type Entry, type EntryStatus } from 'alinea/core/Entry';
   import type { EntryUrlInput, Type } from 'alinea/core/Type';
   export function entryInfo(fileName: string): [name: string, status: EntryStatus];
+  /** The workspace/root/locale layout encoded in a source file path. */
+  export interface EntryFileLocation {
+      workspace: string;
+      root: string;
+      locale: string | null;
+      path: string;
+      versionStatus: EntryStatus;
+      parentDir: string;
+      childrenDir: string;
+      /** Segments taken up by the workspace, root and locale. */
+      levelOffset: number;
+      level: number;
+      parentPaths: Array<string>;
+  }
+  /**
+   * Read back the layout `Config.filePath` and `entryChildrenDir` write:
+   * `[workspace/]root/[locale/]...parents/path[.status].json`.
+   */
+  export function parseEntryFilePath(config: Config, filePath: string): EntryFileLocation;
   export function entryChildrenDir(config: Config, entry: {
       workspace: string;
       root: string;
@@ -5494,6 +5383,8 @@ declare module 'alinea/core/util/EntryFilenames' {
       path: string;
       status: EntryStatus;
   }, parentPaths: Array<string>): string;
+  /** The `<childrenDir>[.status].json` file holding a single entry version. */
+  export function entryVersionFile(childrenDir: string, status: EntryStatus): string;
   export function entryFilepath(config: Config, entry: {
       workspace: string;
       root: string;
@@ -5562,6 +5453,15 @@ declare module 'alinea/core/util/Identifiers' {
   
 }
 
+declare module 'alinea/core/util/IndexedDB' {
+
+  /** Resolve once an IndexedDB transaction has committed. */
+  export function transactionComplete(tx: IDBTransaction): Promise<void>;
+  /** Resolve with the result of an IndexedDB request. */
+  export function requestResult<T>(request: IDBRequest<T>): Promise<T>;
+  
+}
+
 declare module 'alinea/core/util/JWT' {
 
   const algorithms: {
@@ -7000,10 +6900,6 @@ declare module 'alinea/dashboard/atoms/config' {
   export const workspaceAtom: (workspaceKey: string) => import("jotai").Atom<import("alinea/core/Workspace").WorkspaceInternal>;
   export const viewAtoms: (key: string) => import("jotai").Atom<ComponentType | undefined>;
   export const typeAtoms: (typeName: string) => import("jotai").Atom<{
-      type: import("alinea/types").Type;
-      customView: ((props: {
-          type: import("alinea/types").Type;
-      }) => import("react").ReactNode) | ComponentType | undefined;
       fields: import("alinea/core/Type").FieldsDefinition;
       contains?: Array<string | import("alinea/types").Type>;
       orderChildrenBy?: import("alinea/core/OrderBy").OrderBy | Array<import("alinea/core/OrderBy").OrderBy>;
@@ -7021,6 +6917,10 @@ declare module 'alinea/dashboard/atoms/config' {
       label: string;
       allFields: Record<string, import("alinea/core").Field>;
       sections: Array<import("alinea/core/Section").Section>;
+      type: import("alinea/types").Type;
+      customView: ((props: {
+          type: import("alinea/types").Type;
+      }) => import("react").ReactNode) | ComponentType | undefined;
   }>;
   
 }
@@ -7183,7 +7083,7 @@ declare module 'alinea/dashboard/atoms/editor' {
 
 declare module 'alinea/dashboard/atoms/entry' {
 
-  import type { EntryReference, EntryReferenceScan } from 'alinea/core/db/EntryReference';
+  import type { EntryReference } from 'alinea/core/db/EntryReference';
   import { Entry, EntryStatus } from 'alinea/core/Entry';
   import type { Order } from 'alinea/core/Graph';
   import { type EntryDefaultView } from 'alinea/core/Type';
@@ -7209,7 +7109,6 @@ declare module 'alinea/dashboard/atoms/entry' {
   export interface EntryReferences {
       references: Array<EntryReferenceWithSource>;
       total: number;
-      scan: EntryReferenceScan;
   }
   export interface EntryReferenceWithSource {
       reference: EntryReference;
@@ -7262,10 +7161,8 @@ declare module 'alinea/dashboard/atoms/entry' {
           init: null;
       };
       previewEntryReady: Atom<Promise<{
-          title: string;
-          path: string;
-          data: Record<string, unknown>;
           id: string;
+          versionStatus?: EntryStatus;
           status: EntryStatus;
           type: string;
           seeded: string | null;
@@ -7285,12 +7182,13 @@ declare module 'alinea/dashboard/atoms/entry' {
           fileHash: string;
           url: string;
           searchableText: string;
-      }>>;
-      previewEntry: Atom<{
           title: string;
           path: string;
           data: Record<string, unknown>;
+      }>>;
+      previewEntry: Atom<{
           id: string;
+          versionStatus?: EntryStatus;
           status: EntryStatus;
           type: string;
           seeded: string | null;
@@ -7310,6 +7208,9 @@ declare module 'alinea/dashboard/atoms/entry' {
           fileHash: string;
           url: string;
           searchableText: string;
+          title: string;
+          path: string;
+          data: Record<string, unknown>;
       } | undefined>;
       previewUrlReady: Atom<Promise<string | undefined>>;
       previewUrlState: Atom<readonly [false, string | undefined] | readonly [true, string | undefined]>;
@@ -7370,7 +7271,6 @@ declare module 'alinea/dashboard/atoms/entry' {
               };
           }[];
           total: number;
-          scan: EntryReferenceScan;
       }>>;
       incomingReferences: Atom<{
           references: {
@@ -7388,7 +7288,6 @@ declare module 'alinea/dashboard/atoms/entry' {
               };
           }[];
           total: number;
-          scan: EntryReferenceScan;
       } | undefined>;
       type: Atom<string>;
       parentId: Atom<string | null>;
@@ -7469,6 +7368,8 @@ declare module 'alinea/dashboard/atoms/explorer' {
   import type { DragItem, DragTypes, DropOperation, DropTarget } from '@react-types/shared';
   import type { DroppableCollectionOnItemDropEvent, Key } from 'react-aria-components';
   export const dashboardEntryOverviewColumnCount = 5;
+  /** The best ranked matches a search loads into the explorer. */
+  export const searchResultLimit = 100;
   export type ExplorerView = 'card' | 'row';
   export type ExplorerSortBy = 'title' | 'path' | 'size' | 'id' | 'index';
   export type ExplorerSortDirections = 'asc' | 'desc';
@@ -8106,14 +8007,14 @@ declare module 'alinea/dashboard/boot/DashboardWorker' {
   import type { Config } from 'alinea/core/Config';
   import type { LocalConnection } from 'alinea/core/Connection';
   import type { EntryReferenceQuery, EntryReferenceResult } from 'alinea/core/db/EntryReference';
-  import { LocalDB } from 'alinea/core/db/LocalDB';
   import type { Mutation } from 'alinea/core/db/Mutation';
   import type { Source } from 'alinea/core/source/Source';
+  import { EntryStore } from 'alinea/database/EntryStore';
   import { type Activity } from 'alinea/dashboard/boot/ActivityEvent';
   export class DashboardWorker extends EventTarget {
       #private;
-      constructor(source: Source);
-      get db(): LocalDB | Promise<LocalDB>;
+      constructor(source?: Source);
+      get db(): EntryStore | Promise<EntryStore>;
       sync(): Promise<string>;
       sha(): Promise<string>;
       queue(id: string, mutations: Array<Mutation>): Promise<string>;
@@ -8596,6 +8497,8 @@ declare module 'alinea/dashboard/icons' {
   export function IcOutlineTableRows(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
   export function IcOutlineViewList(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
   export function IcRoundDescription(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
+  export function IcRoundBolt(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
+  export function IcRoundInfo(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
   export function IcTwotoneDescription(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
   export function IcTwotoneFolder(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
   export function IcRoundInsertDriveFile(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
@@ -8800,6 +8703,7 @@ declare module 'alinea/dashboard/ViewKeys' {
       MetadataTimestampInput: string;
       MetadataUserInput: string;
       MetadataInput: string;
+      MetadataDetailsView: string;
       NumberInput: string;
       ObjectInput: string;
       PathInput: string;
@@ -8814,6 +8718,1055 @@ 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 { EntryStore } from 'alinea/database/EntryStore';
+  export interface BrowserEntryStoreOptions {
+      indexedDB: IDBFactory;
+      name: string;
+      revision: string;
+  }
+  /** WASM entry store persisted as one SQLite file in IndexedDB. */
+  export class BrowserEntryStore extends EntryStore {
+      #private;
+      static open(config: Config, options: BrowserEntryStoreOptions): Promise<BrowserEntryStore>;
+      private constructor();
+      sync(): Promise<string>;
+      syncWith(remote: RemoteSource, options?: SyncOptions): Promise<string>;
+      mutate(mutations: Array<Mutation>): Promise<{
+          sha: string;
+      }>;
+      write(request: CommitRequest): Promise<{
+          sha: string;
+      }>;
+      close(): Promise<void>;
+      /** Close a superseded store without persisting stale bytes over its
+       * replacement's cache. Supersede always implies a revision change, so the
+       * persisted revision would be discarded on the next open anyway. */
+      abandon(): Promise<void>;
+  }
+  
+}
+
+declare module 'alinea/database/DatabaseSource' {
+
+  import type { ChangesBatch } from 'alinea/core/source/Change';
+  import type { GetBlobsOptions, Source } from 'alinea/core/source/Source';
+  import type { ReadonlyTree } from 'alinea/core/source/Tree';
+  import type { EntryLayer } from 'alinea/database/EntryLayer';
+  /** Read-only Source view backed by exact payload text in an entry database. */
+  export class DatabaseSource implements Source {
+      #private;
+      constructor(database: EntryLayer);
+      getTree(): Promise<ReadonlyTree>;
+      getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
+      getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array<ArrayBufferLike>], any, any>;
+      applyChanges(_batch: ChangesBatch): Promise<void>;
+  }
+  
+}
+
+declare module 'alinea/database/DatabaseTables' {
+
+  import type { Tree } from 'alinea/core/source/Tree';
+  export const DatabaseStateColumns: {
+      id: import("rado").Column<number, [false, false]>;
+      revision: import("rado").Column<string, [false, boolean]>;
+      /** Merkle tree matching the indexed source revision. */
+      tree: import("rado").JsonColumn<Tree, import("rado").Nullability>;
+  };
+  export const DatabaseStateTable: import("rado").Table<{
+      id: import("rado").Column<number, [false, false]>;
+      revision: import("rado").Column<string, [false, boolean]>;
+      /** Merkle tree matching the indexed source revision. */
+      tree: import("rado").JsonColumn<Tree, import("rado").Nullability>;
+  }, "alinea_database_state">;
+  export const DatabaseMetadataColumns: {
+      id: import("rado").Column<number, [false, false]>;
+      /** The database version whose layout the tables have. */
+      version: import("rado").Column<number, [false, boolean]>;
+      configFingerprint: import("rado").Column<string, [false, boolean]>;
+  };
+  export const DatabaseMetadataTable: import("rado").Table<{
+      id: import("rado").Column<number, [false, false]>;
+      /** The database version whose layout the tables have. */
+      version: import("rado").Column<number, [false, boolean]>;
+      configFingerprint: import("rado").Column<string, [false, boolean]>;
+  }, "alinea_database_metadata">;
+  /** Filesystem metadata of the source files indexed by this database. */
+  export const SourceFileColumns: {
+      path: import("rado").Column<string, [false, false]>;
+      /** Last modification time in milliseconds. */
+      mtime: import("rado").Column<number, [false, boolean]>;
+      size: import("rado").Column<number, [false, boolean]>;
+  };
+  export const SourceFileTable: import("rado").Table<{
+      path: import("rado").Column<string, [false, false]>;
+      /** Last modification time in milliseconds. */
+      mtime: import("rado").Column<number, [false, boolean]>;
+      size: import("rado").Column<number, [false, boolean]>;
+  }, "alinea_source_file">;
+  
+}
+
+declare module 'alinea/database/driver/RuntimeDatabase' {
+
+  import type { Database, DatabaseOptions } from 'rado';
+  export interface RuntimeDatabaseOptions extends DatabaseOptions {
+      path?: string;
+      data?: Uint8Array;
+      readonly?: boolean;
+  }
+  /** Select a native Node/Bun driver for files and WASM for byte buffers. */
+  export function runtimeDatabase(options?: RuntimeDatabaseOptions): Promise<Database>;
+  
+}
+
+declare module 'alinea/database/driver/WasmDatabase' {
+
+  import { connect } from 'rado/driver/sql.js';
+  export interface WasmDatabaseHandle {
+      database: ReturnType<typeof connect>;
+      export(): Uint8Array;
+  }
+  /** Open an in-memory WASM connection, optionally from a complete SQLite file. */
+  export function openWasmDatabase(data?: Uint8Array): Promise<WasmDatabaseHandle>;
+  export function wasmDatabase(data?: Uint8Array): Promise<import("rado").SyncDatabase<"sqlite">>;
+  
+}
+
+declare module 'alinea/database/entry/EntryData' {
+
+  import { type Database, type Sql } from 'rado';
+  import { type EntryIndexTarget } from 'alinea/database/entry/EntryTable';
+  /**
+   * Whether this SQLite stores entry data as JSONB, which reads paths of large
+   * documents without parsing them. Older versions store JSON text.
+   */
+  export function supportsJsonb(db: Database): Promise<boolean>;
+  /** Whether the entry index holds rows stored as JSONB. */
+  export function hasJsonbRows(db: Database): Promise<boolean>;
+  /** Fail clearly when this SQLite cannot read the JSONB rows of a database. */
+  export function assertReadableData(db: Database): Promise<void>;
+  /** The data as JSON text, whether stored as text or JSONB. */
+  export function entryDataText(entry: Pick<EntryIndexTarget, 'data'>): Sql<string>;
+  
+}
+
+declare module 'alinea/database/entry/EntryTable' {
+
+  import type { Entry, EntryStatus } from 'alinea/core/Entry';
+  import { type Table } from 'rado';
+  /** One complete authored entry version. Only arrays and authored data are JSON. */
+  export const EntryIndexColumns: {
+      /**
+       * Also the rowid of the version's full-text search row. Declared, so VACUUM
+       * and copies into overlay tables keep it.
+       */
+      rowid: import("rado").Column<number, [false, false]>;
+      versionId: import("rado").Column<string, [false, boolean]>;
+      id: import("rado").Column<string, [false, boolean]>;
+      locale: import("rado").Column<string, import("rado").Nullability>;
+      versionStatus: import("rado").Column<EntryStatus, [false, boolean]>;
+      status: import("rado").Column<EntryStatus, [false, boolean]>;
+      type: import("rado").Column<string, [false, boolean]>;
+      title: import("rado").Column<string, [false, boolean]>;
+      workspace: import("rado").Column<string, [false, boolean]>;
+      root: import("rado").Column<string, [false, boolean]>;
+      sourceRoot: import("rado").Column<string, import("rado").Nullability>;
+      parentId: import("rado").Column<string, import("rado").Nullability>;
+      parents: import("rado").Column<string[], [false, boolean]>;
+      level: import("rado").Column<number, [false, boolean]>;
+      index: import("rado").Column<string, [false, boolean]>;
+      path: import("rado").Column<string, [false, boolean]>;
+      /** Full source path of this authored version. */
+      filePath: import("rado").Column<string, [false, boolean]>;
+      fileHash: import("rado").Column<string, [false, boolean]>;
+      parentDir: import("rado").Column<string, [false, boolean]>;
+      childrenDir: import("rado").Column<string, [false, boolean]>;
+      url: import("rado").Column<string, [false, boolean]>;
+      active: import("rado").Column<boolean, [false, boolean]>;
+      main: import("rado").Column<boolean, [false, boolean]>;
+      visible: import("rado").Column<boolean, [false, boolean]>;
+      seeded: import("rado").Column<string, import("rado").Nullability>;
+      rowHash: import("rado").Column<string, [false, boolean]>;
+      /** Hash of this entry's child directory in the synced source tree. */
+      childrenSha: import("rado").Column<string, import("rado").Nullability>;
+      /** Exact source blob for seeded rows whose expanded data differs. */
+      payload: import("rado").Column<string, import("rado").Nullability>;
+      /**
+       * Exact source JSON, or expanded JSON for seeded rows. Stored as JSONB where
+       * SQLite supports it; read it as text with `entryDataText`.
+       */
+      data: import("rado").Column<string, [false, boolean]>;
+  };
+  export function entryIndexTable(name: string, temporary?: boolean): Table<{
+      /**
+       * Also the rowid of the version's full-text search row. Declared, so VACUUM
+       * and copies into overlay tables keep it.
+       */
+      rowid: import("rado").Column<number, [false, false]>;
+      versionId: import("rado").Column<string, [false, boolean]>;
+      id: import("rado").Column<string, [false, boolean]>;
+      locale: import("rado").Column<string, import("rado").Nullability>;
+      versionStatus: import("rado").Column<EntryStatus, [false, boolean]>;
+      status: import("rado").Column<EntryStatus, [false, boolean]>;
+      type: import("rado").Column<string, [false, boolean]>;
+      title: import("rado").Column<string, [false, boolean]>;
+      workspace: import("rado").Column<string, [false, boolean]>;
+      root: import("rado").Column<string, [false, boolean]>;
+      sourceRoot: import("rado").Column<string, import("rado").Nullability>;
+      parentId: import("rado").Column<string, import("rado").Nullability>;
+      parents: import("rado").Column<string[], [false, boolean]>;
+      level: import("rado").Column<number, [false, boolean]>;
+      index: import("rado").Column<string, [false, boolean]>;
+      path: import("rado").Column<string, [false, boolean]>;
+      /** Full source path of this authored version. */
+      filePath: import("rado").Column<string, [false, boolean]>;
+      fileHash: import("rado").Column<string, [false, boolean]>;
+      parentDir: import("rado").Column<string, [false, boolean]>;
+      childrenDir: import("rado").Column<string, [false, boolean]>;
+      url: import("rado").Column<string, [false, boolean]>;
+      active: import("rado").Column<boolean, [false, boolean]>;
+      main: import("rado").Column<boolean, [false, boolean]>;
+      visible: import("rado").Column<boolean, [false, boolean]>;
+      seeded: import("rado").Column<string, import("rado").Nullability>;
+      rowHash: import("rado").Column<string, [false, boolean]>;
+      /** Hash of this entry's child directory in the synced source tree. */
+      childrenSha: import("rado").Column<string, import("rado").Nullability>;
+      /** Exact source blob for seeded rows whose expanded data differs. */
+      payload: import("rado").Column<string, import("rado").Nullability>;
+      /**
+       * Exact source JSON, or expanded JSON for seeded rows. Stored as JSONB where
+       * SQLite supports it; read it as text with `entryDataText`.
+       */
+      data: import("rado").Column<string, [false, boolean]>;
+  }, string>;
+  export type EntryIndexTarget = Table<typeof EntryIndexColumns>;
+  export const EntryIndexTable: Table<{
+      /**
+       * Also the rowid of the version's full-text search row. Declared, so VACUUM
+       * and copies into overlay tables keep it.
+       */
+      rowid: import("rado").Column<number, [false, false]>;
+      versionId: import("rado").Column<string, [false, boolean]>;
+      id: import("rado").Column<string, [false, boolean]>;
+      locale: import("rado").Column<string, import("rado").Nullability>;
+      versionStatus: import("rado").Column<EntryStatus, [false, boolean]>;
+      status: import("rado").Column<EntryStatus, [false, boolean]>;
+      type: import("rado").Column<string, [false, boolean]>;
+      title: import("rado").Column<string, [false, boolean]>;
+      workspace: import("rado").Column<string, [false, boolean]>;
+      root: import("rado").Column<string, [false, boolean]>;
+      sourceRoot: import("rado").Column<string, import("rado").Nullability>;
+      parentId: import("rado").Column<string, import("rado").Nullability>;
+      parents: import("rado").Column<string[], [false, boolean]>;
+      level: import("rado").Column<number, [false, boolean]>;
+      index: import("rado").Column<string, [false, boolean]>;
+      path: import("rado").Column<string, [false, boolean]>;
+      /** Full source path of this authored version. */
+      filePath: import("rado").Column<string, [false, boolean]>;
+      fileHash: import("rado").Column<string, [false, boolean]>;
+      parentDir: import("rado").Column<string, [false, boolean]>;
+      childrenDir: import("rado").Column<string, [false, boolean]>;
+      url: import("rado").Column<string, [false, boolean]>;
+      active: import("rado").Column<boolean, [false, boolean]>;
+      main: import("rado").Column<boolean, [false, boolean]>;
+      visible: import("rado").Column<boolean, [false, boolean]>;
+      seeded: import("rado").Column<string, import("rado").Nullability>;
+      rowHash: import("rado").Column<string, [false, boolean]>;
+      /** Hash of this entry's child directory in the synced source tree. */
+      childrenSha: import("rado").Column<string, import("rado").Nullability>;
+      /** Exact source blob for seeded rows whose expanded data differs. */
+      payload: import("rado").Column<string, import("rado").Nullability>;
+      /**
+       * Exact source JSON, or expanded JSON for seeded rows. Stored as JSONB where
+       * SQLite supports it; read it as text with `entryDataText`.
+       */
+      data: import("rado").Column<string, [false, boolean]>;
+  }, string>;
+  /** An Entry plus the physical-version and local-index fields. */
+  export interface IndexedEntry extends Entry {
+      versionStatus: EntryStatus;
+      /** Exact source text matching fileHash. */
+      payload?: string;
+      /** False for authored versions suppressed by inherited status in normal queries. */
+      visible?: boolean;
+      /** First source-directory segment below the content root (not the URL slug). */
+      sourceRoot?: string | null;
+      /** Hash of this entry's child directory in the synced source tree. */
+      childrenSha?: string | null;
+  }
+  export function entryIndexRow(entry: IndexedEntry): {
+      versionId: string;
+      id: string;
+      locale: string | null;
+      versionStatus: EntryStatus;
+      status: EntryStatus;
+      type: string;
+      title: string;
+      workspace: string;
+      root: string;
+      sourceRoot: string | null;
+      parentId: string | null;
+      parents: string[];
+      level: number;
+      index: string;
+      path: string;
+      filePath: string;
+      fileHash: string;
+      parentDir: string;
+      childrenDir: string;
+      url: string;
+      active: boolean;
+      main: boolean;
+      visible: boolean;
+      seeded: string | null;
+      rowHash: string;
+      childrenSha: string | null;
+      payload: string | null;
+      data: string;
+  };
+  export function storedEntryData(value: unknown, path: string): Record<string, unknown>;
+  
+}
+
+declare module 'alinea/database/entry/EntryView' {
+
+  import { type Database } from 'rado';
+  import type { EntrySyncTarget } from 'alinea/database/sync/EntrySyncer';
+  /** The tables reads of a target go to: an unwritten view reads its parent's. */
+  export function entryReadTarget(target: EntrySyncTarget): EntrySyncTarget;
+  /**
+   * Named, copy-on-write entry and search tables over another target. A view
+   * reads its parent until the first write copies the parent's rows into
+   * temporary tables of its own, which from then on no longer follow the parent.
+   */
+  export class EntryView {
+      #private;
+      readonly target: EntrySyncTarget;
+      private constructor();
+      static create(db: Database, name: string, parent: EntrySyncTarget, revision: string): Promise<EntryView>;
+      get readTarget(): EntrySyncTarget;
+      /**
+       * Copy the parent's rows into this view's tables. Await this before every
+       * write through the view: until then reads go to the parent.
+       */
+      diverge(): Promise<void>;
+      close(): Promise<void>;
+  }
+  
+}
+
+declare module 'alinea/database/EntryDatabase' {
+
+  import type { Config } from 'alinea/core/Config';
+  import type { FileStat } from 'alinea/core/source/FSSource';
+  import { type Database } from 'rado';
+  import { EntryLayer, type EntryDatabaseOptions, type EntrySyncResult } from 'alinea/database/EntryLayer';
+  /** A queryable entry database owning its SQLite connection. */
+  export class EntryDatabase extends EntryLayer {
+      #private;
+      constructor(config: Config, db: Database, options?: EntryDatabaseOptions);
+      static createSchema(db: Database, revision: string, configFingerprint?: string): Promise<void>;
+      /**
+       * Derive every entry again with another config, recording the fingerprint
+       * so a later open recognizes the database as written by that config.
+       */
+      reindex(config: Config, configFingerprint?: string): Promise<EntrySyncResult>;
+      /** File stats recorded by the last filesystem sync of this database. */
+      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>;
+      protected releaseLayer(): Promise<void>;
+  }
+  
+}
+
+declare module 'alinea/database/EntryLayer' {
+
+  import type { Config } from 'alinea/core/Config';
+  import type { CommitRequest } from 'alinea/core/db/CommitRequest';
+  import type { EntryReferenceQuery, EntryReferenceResult } from 'alinea/core/db/EntryReference';
+  import type { Mutation } from 'alinea/core/db/Mutation';
+  import type { SyncOptions } from 'alinea/core/db/LocalStore';
+  import { Graph, type AnyQueryResult, type GraphQuery } from 'alinea/core/Graph';
+  import { Policy } from 'alinea/core/Role';
+  import { OverlaySource } from 'alinea/core/source/OverlaySource';
+  import { type GetBlobsOptions, type RemoteSource, type Source } from 'alinea/core/source/Source';
+  import { ReadonlyTree } from 'alinea/core/source/Tree';
+  import { TaskQueue } from 'alinea/core/util/Async';
+  import { type Database } from 'rado';
+  import { EntryView } from 'alinea/database/entry/EntryView';
+  import { EntrySyncer, type EntrySyncTarget } from 'alinea/database/sync/EntrySyncer';
+  export interface EntryLayerState {
+      /** Read connection, or the write transaction of a working layer. */
+      db: Database;
+      /** Serializes every task on the connection, shared by its overlays. */
+      queue: TaskQueue;
+      syncer: EntrySyncer;
+      target: EntrySyncTarget;
+      /** The copy-on-write table behind an overlay's target. */
+      view?: EntryView;
+      /** The layer an overlay was created from. */
+      parent?: EntryLayer;
+      tree?: ReadonlyTree;
+      initialTree?: ReadonlyTree;
+      /** The connection is already inside a transaction: never open nested ones. */
+      transactional?: boolean;
+  }
+  export interface EntryDatabaseOptions {
+      includedAtBuild?(filePath: string): boolean | Promise<boolean>;
+  }
+  export interface EntryApplyOptions {
+      source: Source;
+      policy?: Policy;
+  }
+  export type EntryChangeListener = (change: EntrySyncResult) => void;
+  export interface EntrySyncResult {
+      revision: string;
+      /** Includes source changes, deletions, and entries changed by inheritance. */
+      changedEntryIds: ReadonlyArray<string>;
+  }
+  export interface EntryApplyResult extends EntrySyncResult {
+      request: CommitRequest;
+  }
+  export interface EntryDatabaseOverlay extends AsyncDisposable {
+      database: EntryLayer;
+      source: OverlaySource;
+      close(): Promise<void>;
+  }
+  /** One queryable layer of the entry index: a database or a view over one. */
+  export class EntryLayer extends Graph implements AsyncDisposable {
+      #private;
+      constructor(config: Config, options: EntryDatabaseOptions, state: EntryLayerState);
+      get config(): Config;
+      includedAtBuild(filePath: string): boolean | Promise<boolean>;
+      /** Whether this layer was closed, and answers only from a replacement. */
+      get closed(): boolean;
+      /**
+       * Synchronize a source through this layer's single prepared syncer, without
+       * keeping an in-memory copy of its entries.
+       */
+      syncWith(source: RemoteSource, options?: SyncOptions): Promise<EntrySyncResult>;
+      /**
+       * Adopt another config and derive every entry again from the payloads this
+       * layer stores. The rows of the previous config are replaced within one
+       * transaction, so reads keep answering from them until the replacement is
+       * committed. Only a layer without overlays can be reindexed.
+       */
+      protected reindexEntries(config: Config, reset?: (tx: Database) => Promise<void>): Promise<EntrySyncResult>;
+      /** Atomically plan and apply mutations through a private working layer. */
+      apply(mutations: ReadonlyArray<Mutation>, options: EntryApplyOptions): Promise<EntryApplyResult>;
+      /** Plan mutations like apply, then roll them back. */
+      plan(mutations: ReadonlyArray<Mutation>, options: EntryApplyOptions): Promise<CommitRequest>;
+      close(): Promise<void>;
+      /** Release what this layer owns, serialized with the read connection. */
+      protected releaseLayer(): Promise<void>;
+      [Symbol.asyncDispose](): Promise<void>;
+      getRevision(): Promise<string>;
+      getTree(): Promise<ReadonlyTree>;
+      getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
+      /** Run a task serialized with every other read on this connection. */
+      protected withReadConnection<T>(run: () => Promise<T>): Promise<T>;
+      /** Create and synchronize a copy-on-write layer over this one. */
+      overlay(source: RemoteSource): Promise<EntryLayer>;
+      /** Create an initially empty writable source and database layer. */
+      createOverlay(): Promise<EntryDatabaseOverlay>;
+      resolve<const Query extends GraphQuery>(query: Query): Promise<AnyQueryResult<Query>>;
+      /** Scan references in bounded pages without retaining an entry index. */
+      referencesTo(query: EntryReferenceQuery): Promise<EntryReferenceResult>;
+      onChange(listener: EntryChangeListener): () => void;
+  }
+  
+}
+
+declare module 'alinea/database/EntryStore' {
+
+  import type { Config } from 'alinea/core/Config';
+  import type { GetBlobsOptions, RemoteSource, Source } from 'alinea/core/source/Source';
+  import { ReadonlyTree } from 'alinea/core/source/Tree';
+  import type { AnyQueryResult, GraphQuery } from 'alinea/core/Graph';
+  import type { Mutation } from 'alinea/core/db/Mutation';
+  import type { Policy } from 'alinea/core/Role';
+  import type { EntryReferenceQuery, EntryReferenceResult } from 'alinea/core/db/EntryReference';
+  import { type CommitRequest } from 'alinea/core/db/CommitRequest';
+  import type { LocalStore, SyncOptions } from 'alinea/core/db/LocalStore';
+  import { WriteableGraph } from 'alinea/core/db/WriteableGraph';
+  import type { UploadMetadata, UploadResponse } from 'alinea/core/Connection';
+  import type { EntryChangeListener, EntryLayer } from 'alinea/database/EntryLayer';
+  export interface EntryStoreOptions {
+      ownsDatabase?: boolean;
+      sourceFollowsDatabase?: boolean;
+      close?: () => Promise<void>;
+  }
+  /** Source and commit lifecycle around the transport-neutral SQLite database. */
+  export class EntryStore extends WriteableGraph implements LocalStore, AsyncDisposable {
+      #private;
+      /** Replaced only by a reindex, which derives every entry again. */
+      config: Config;
+      readonly database: EntryLayer;
+      readonly source: Source;
+      constructor(config: Config, database: EntryLayer, source: Source, options?: EntryStoreOptions);
+      static memory(config: Config, source: Source): Promise<EntryStore>;
+      get sha(): Promise<string>;
+      includedAtBuild(filePath: string): boolean | Promise<boolean>;
+      /**
+       * Preview queries share a single overlay, which each query first brings to
+       * its own payload over the current store revision. The overlay diffs from
+       * the tree it shows, so a switch restores the previously previewed entry and
+       * follows store syncs without copying the entries again.
+       */
+      resolve<Query extends GraphQuery>(query: Query): Promise<AnyQueryResult<Query>>;
+      /** Close the preview overlay, which keeps this store's database open. */
+      protected closePreviews(): Promise<void>;
+      referencesTo(query: EntryReferenceQuery): Promise<EntryReferenceResult>;
+      onChange(listener: EntryChangeListener): () => void;
+      sync(): Promise<string>;
+      /** Keep the writable source and its query database at one remote revision. */
+      syncWith(remote: RemoteSource, options?: SyncOptions): Promise<string>;
+      /** Create a persistent copy-on-write session over this store. */
+      overlay(remote: RemoteSource): Promise<EntryStore>;
+      /** Plan a commit without changing this store. */
+      request(mutations: ReadonlyArray<Mutation>, policy?: Policy): Promise<CommitRequest>;
+      mutate(mutations: Array<Mutation>): Promise<{
+          sha: string;
+      }>;
+      write(request: CommitRequest): Promise<{
+          sha: string;
+      }>;
+      getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
+      getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncIterable<[sha: string, blob: Uint8Array<ArrayBufferLike>]>;
+      prepareUpload(_file: string, _metadata?: UploadMetadata): Promise<UploadResponse>;
+      /** Whether the underlying database was closed. */
+      get closed(): boolean;
+      close(): Promise<void>;
+      [Symbol.asyncDispose](): Promise<void>;
+  }
+  
+}
+
+declare module 'alinea/database/EntryTransaction' {
+
+  import { type Policy } from 'alinea/core/Role';
+  import { OverlaySource } from 'alinea/core/source/OverlaySource';
+  import { SourceTransaction } from 'alinea/core/source/Source';
+  import type { ReadonlyTree } from 'alinea/core/source/Tree';
+  import { type CommitRequest } from 'alinea/core/db/CommitRequest';
+  import type { ArchiveMutation, CreateMutation, MoveMutation, Mutation, PublishMutation, RemoveFileMutation, RemoveMutation, UnpublishMutation, UpdateMutation, UploadFileMutation } from 'alinea/core/db/Mutation';
+  import type { EntryLayer } from 'alinea/database/EntryLayer';
+  type Op<T> = Omit<T, 'op'>;
+  /**
+   * Plans mutations inside the receiver's write transaction. Each mutation is
+   * flushed so subsequent mutations query its result without retaining an
+   * in-memory entry index. SQLite rolls the full batch back on failure.
+   */
+  export class EntryTransaction implements AsyncDisposable {
+      #private;
+      /** @internal Constructed by EntryLayer.apply. */
+      constructor(workingDatabase: EntryLayer, workingSource: OverlaySource, sourceTransaction: SourceTransaction, from: ReadonlyTree, policy: Policy);
+      get changedEntryIds(): Array<string>;
+      apply(mutations: ReadonlyArray<Mutation>): Promise<void>;
+      create({ locale, type, data, root, workspace, fromSeed, parentId, id, insertOrder, status, overwrite }: Op<CreateMutation>): Promise<void>;
+      update({ id, locale, status, set }: Op<UpdateMutation>): Promise<void>;
+      publish({ id, locale, status }: Op<PublishMutation>): Promise<void>;
+      unpublish({ id, locale }: Op<UnpublishMutation>): Promise<void>;
+      archive({ id, locale }: Op<ArchiveMutation>): Promise<void>;
+      move({ id, target, dropPosition, targetType }: Op<MoveMutation>): Promise<void>;
+      remove({ id, locale, status }: Op<RemoveMutation>): Promise<void>;
+      removeFile(mutation: Op<RemoveFileMutation>): void;
+      uploadFile(mutation: Op<UploadFileMutation>): void;
+      toRequest(): Promise<CommitRequest>;
+      close(): Promise<void>;
+      [Symbol.asyncDispose](): Promise<void>;
+  }
+  export {};
+  
+}
+
+declare module 'alinea/database/EntryUrlAliases' {
+
+  import { Type } from 'alinea/core/Type';
+  export function dataWithUrlAlias(type: Type, data: Record<string, unknown>, previousUrl: string, currentUrl: string): Record<string, unknown>;
+  
+}
+
+declare module 'alinea/database/LocalDB' {
+
+  import type { AnyQueryResult, GraphQuery } from 'alinea/core/Graph';
+  import type { GetBlobsOptions, RemoteSource, Source } from 'alinea/core/source/Source';
+  import type { Config } from 'alinea/core/Config';
+  import type { UploadMetadata, UploadResponse } from 'alinea/core/Connection';
+  import type { CommitRequest } from 'alinea/core/db/CommitRequest';
+  import type { EntryReferenceQuery, EntryReferenceResult } from 'alinea/core/db/EntryReference';
+  import type { LocalStore, SyncOptions } from 'alinea/core/db/LocalStore';
+  import type { Mutation } from 'alinea/core/db/Mutation';
+  import { WriteableGraph } from 'alinea/core/db/WriteableGraph';
+  import type { Policy } from 'alinea/core/Role';
+  /**
+   * Sync-constructor convenience over `EntryStore.memory()`.
+   * This facade is backed by the SQLite engine.
+   */
+  export class LocalDB extends WriteableGraph implements LocalStore, AsyncDisposable {
+      #private;
+      readonly config: Config;
+      readonly source: Source;
+      readonly events: EventTarget;
+      constructor(config: Config, source?: Source);
+      get sha(): Promise<string>;
+      includedAtBuild(filePath: string): Promise<boolean>;
+      resolve<Query extends GraphQuery>(query: Query): Promise<AnyQueryResult<Query>>;
+      referencesTo(query: EntryReferenceQuery): Promise<EntryReferenceResult>;
+      getTreeIfDifferent(sha: string): Promise<import("alinea/core/source/Tree").ReadonlyTree | undefined>;
+      getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncIterable<[sha: string, blob: Uint8Array<ArrayBufferLike>]>;
+      sync(): Promise<string>;
+      syncWith(remote: RemoteSource, options?: SyncOptions): Promise<string>;
+      request(mutations: ReadonlyArray<Mutation>, policy?: Policy): Promise<CommitRequest>;
+      mutate(mutations: Array<Mutation>): Promise<{
+          sha: string;
+      }>;
+      write(request: CommitRequest): Promise<{
+          sha: string;
+      }>;
+      prepareUpload(_file: string, _metadata?: UploadMetadata): Promise<UploadResponse>;
+      close(): Promise<void>;
+      [Symbol.asyncDispose](): Promise<void>;
+  }
+  
+}
+
+declare module 'alinea/database/query/Condition' {
+
+  import { type HasSql, type Sql } from 'rado';
+  type FieldSql = (name: string) => HasSql;
+  export function jsonField(target: HasSql, segments: Array<string>): HasSql<unknown>;
+  /** 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 arrayIncludes(field: HasSql, predicate: (item: HasSql) => Sql<boolean>, depth?: number): Sql<boolean>;
+  export {};
+  
+}
+
+declare module 'alinea/database/query/EntryQuery' {
+
+  import type { Config } from 'alinea/core/Config';
+  import type { Field } from 'alinea/core/Field';
+  import type { GraphQuery, Status } from 'alinea/core/Graph';
+  import { type Scope } from 'alinea/core/Scope';
+  import { type HasSql, type SelectionInput, type Sql } from 'rado';
+  import { type EntryIndexTarget } from 'alinea/database/entry/EntryTable';
+  import { searchQuery, type EntrySearchTarget } from 'alinea/database/query/Search';
+  interface RelationProjection {
+      path: Array<string>;
+      plan: ProjectionPlan;
+  }
+  interface FieldProjection {
+      path: Array<string>;
+      field: Field;
+  }
+  export interface ProjectionPlan {
+      count: boolean;
+      single: boolean;
+      /** Rows carry the selection as `value`, next to the columns they need. */
+      wrapped: boolean;
+      relations: Array<RelationProjection>;
+      fields: Array<FieldProjection>;
+  }
+  /** Rows visible under a query status; the default addresses published rows. */
+  export function statusCondition(entry: EntryIndexTarget, status?: Status): Sql<boolean>;
+  /**
+   * Rows in one locale; null is unlocalized. Stored locales use the configured
+   * spelling, so a requested locale matches any case of it.
+   */
+  export function localeCondition(scope: Scope, entry: EntryIndexTarget, locale: string | null | HasSql<string | null>): Sql<boolean>;
+  interface EntryQueryOptions {
+      source?: EntryIndexTarget;
+      search?: ReturnType<typeof searchQuery>;
+      entry?: EntryIndexTarget;
+      depth?: number;
+      baseEntry?: EntryIndexTarget;
+      searchTable?: EntrySearchTarget;
+  }
+  export function compileEntryQuery(config: Config, query: GraphQuery, options?: EntryQueryOptions): {
+      rows: import("rado").Select<SelectionInput, import("rado/core/MetaData").QueryMeta>;
+      plan: ProjectionPlan;
+  };
+  export {};
+  
+}
+
+declare module 'alinea/database/query/EntryReferences' {
+
+  import type { Config } from 'alinea/core/Config';
+  import type { EntryReferenceQuery, EntryReferenceResult } from 'alinea/core/db/EntryReference';
+  import { type Database } from 'rado';
+  import { type EntryIndexTarget } from 'alinea/database/entry/EntryTable';
+  /** Scan references in bounded pages on the caller's active transaction. */
+  export function queryEntryReferences(config: Config, db: Database, entry: EntryIndexTarget, query: EntryReferenceQuery): Promise<EntryReferenceResult>;
+  
+}
+
+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';
+  /** Expand the stored references as SQL rows, retaining list order and duplicates. */
+  export function linkRelation(source: EntryIndexTarget, field: string, multiple: boolean): {
+      target: Sql<unknown>;
+      id: Sql<string>;
+      ordinal: Sql<number>;
+  };
+  /** Restrict related identities in SQL before the query's own filters/paging. */
+  export function relationCondition(entry: EntryIndexTarget, query: EdgeQuery, source: EntryIndexTarget): Sql<boolean>;
+  
+}
+
+declare module 'alinea/database/query/ResolveQuery' {
+
+  import type { Config } from 'alinea/core/Config';
+  import type { GraphQuery } from 'alinea/core/Graph';
+  import { type Database } from 'rado';
+  import type { EntryIndexTarget } from 'alinea/database/entry/EntryTable';
+  import type { EntrySearchTarget, SearchQuery } from 'alinea/database/query/Search';
+  /** Query dependencies bound to one connection and its current transaction. */
+  export interface EntryQueryContext {
+      config: Config;
+      database: Database;
+      entries: EntryIndexTarget;
+      searchTable: EntrySearchTarget;
+      search(input: GraphQuery['search']): Promise<SearchQuery | undefined>;
+      includedAtBuild(filePath: string): boolean | Promise<boolean>;
+  }
+  export function resolveEntryQuery(query: GraphQuery, context: EntryQueryContext): Promise<unknown>;
+  
+}
+
+declare module 'alinea/database/query/Search' {
+
+  import { type Database, type HasSql, type Sql, type Table } from 'rado';
+  import type { EntryIndexTarget } from 'alinea/database/entry/EntryTable';
+  /**
+   * The FTS5 index of an entry table. Sync writes a row for every entry version
+   * under the rowid of its entry row; the body is the version's searchable text.
+   */
+  const EntrySearchColumns: {
+      rowid: import("rado").Column<number, [false, false]>;
+      title: import("rado").Column<string, [false, boolean]>;
+      body: import("rado").Column<string, [false, boolean]>;
+  };
+  export type EntrySearchTarget = Table<typeof EntrySearchColumns>;
+  export function entrySearchTable(name: string, temporary?: boolean): EntrySearchTarget;
+  export const EntrySearchTable: EntrySearchTarget;
+  export interface SearchQuery {
+      target: Sql;
+      identity: Sql<boolean>;
+      condition: Sql<boolean>;
+      rank: Sql<number>;
+      snippet(start: HasSql, end: HasSql, cutOff: HasSql, limit: HasSql): Sql<string>;
+  }
+  export function createSearch(db: Database, search: EntrySearchTarget): Promise<void>;
+  /** The searchable text of an entry row, read from its search row. */
+  export function searchableText(entry: EntryIndexTarget, search: EntrySearchTarget): Sql<string>;
+  export function searchTokens(input: string | Array<string> | undefined): RegExpMatchArray | [] | undefined;
+  export interface SearchQueryOptions {
+      /** Indexed spellings a token may also match, besides its prefix. */
+      alternatives?(token: string): ReadonlyArray<string>;
+  }
+  export function searchQuery(input: string | Array<string> | undefined, entry: EntryIndexTarget, target: EntrySearchTarget, options?: SearchQueryOptions): SearchQuery | undefined;
+  /** The edits a token may be away from an indexed term: none below five
+   * characters, one up to fourteen, then one more per ten. */
+  export function fuzzyDistance(token: string): number;
+  export function dropVocabulary(db: Database, search: EntrySearchTarget): Promise<void>;
+  /**
+   * The terms of one FTS5 table, loaded once per database revision. Query tokens
+   * expand to indexed terms within a small edit distance, so a typo still
+   * finds the entry.
+   */
+  export class SearchVocabulary {
+      #private;
+      load(db: Database, search: EntrySearchTarget, revision: string): Promise<void>;
+      /** Indexed terms close to a token, most frequent first; prefixes of the
+       * token are left to the prefix match. */
+      alternatives(token: string): Array<string>;
+  }
+  export {};
+  
+}
+
+declare module 'alinea/database/sync/Derive' {
+
+  import type { Config } from 'alinea/core/Config';
+  import { type SyncChanges } from 'alinea/database/sync/Ingest';
+  import type { SyncQueries } from 'alinea/database/sync/SyncQueries';
+  /**
+   * Derive parents, statuses and urls for what a merge changed, and for what
+   * inherits from it. Resolves to the sorted ids of every entry that changed.
+   */
+  export function deriveEntries(config: Config, queries: SyncQueries, changes: SyncChanges, validate: boolean): Promise<Array<string>>;
+  
+}
+
+declare module 'alinea/database/sync/EntryParser' {
+
+  import type { Config } from 'alinea/core/Config';
+  import type { IndexedEntry } from 'alinea/database/entry/EntryTable';
+  /** Parse one source blob into the entry fields that do not depend on its tree. */
+  export function parseSourceEntry(config: Config, filePath: string, fileHash: string, blob: Uint8Array): IndexedEntry;
+  
+}
+
+declare module 'alinea/database/sync/EntrySyncer' {
+
+  import type { Config } from 'alinea/core/Config';
+  import type { RemoteSource } from 'alinea/core/source/Source';
+  import { ReadonlyTree } from 'alinea/core/source/Tree';
+  import type { Database, Table } from 'rado';
+  import { type DatabaseStateColumns } from 'alinea/database/DatabaseTables';
+  import { type EntryIndexTarget } from 'alinea/database/entry/EntryTable';
+  import { type EntrySearchTarget } from 'alinea/database/query/Search';
+  export interface EntrySyncTarget {
+      entries: EntryIndexTarget;
+      state: Table<typeof DatabaseStateColumns>;
+      /** The full-text index of the entries, written along with them. */
+      search: EntrySearchTarget;
+      /**
+       * Whether the state records the synced source tree, so the database can be
+       * reopened and synced from it. A temporary overlay keeps its tree in memory.
+       */
+      recordsTree?: boolean;
+  }
+  export const EntrySyncRoot: EntrySyncTarget;
+  export interface EntrySyncOptions {
+      previousTree?: ReadonlyTree;
+      withinTransaction?: boolean;
+      /** Skip entry validation for a source whose entries were already validated. */
+      validate?: boolean;
+  }
+  /** Prepared, serialized source synchronization for one database connection. */
+  export class EntrySyncer {
+      #private;
+      constructor(config: Config, db: Database);
+      /** Derive later syncs with another config; prepared statements are shared. */
+      reconfigure(config: Config): Promise<void>;
+      /** Stream a source/tree diff directly into the canonical SQLite table. */
+      sync(target: EntrySyncTarget, source: RemoteSource, tree: ReadonlyTree, fromRevision: string, options?: EntrySyncOptions): Promise<Array<string>>;
+      /** Release prepared statements belonging to a closed named target. */
+      release(target: EntrySyncTarget): Promise<void>;
+      close(): Promise<void>;
+  }
+  
+}
+
+declare module 'alinea/database/sync/Ingest' {
+
+  import type { Config } from 'alinea/core/Config';
+  import type { RemoteSource } from 'alinea/core/source/Source';
+  import { ReadonlyTree } from 'alinea/core/source/Tree';
+  import { type SyncQueries } from 'alinea/database/sync/SyncQueries';
+  /** What merging a source tree into the entry table changed. */
+  export interface SyncChanges {
+      /** Entries with a version that was added, replaced or removed. */
+      touched: Set<string>;
+      /** Versions written from their source file, with the url parsed from it. */
+      inserted: Set<string>;
+      /** Entries with a touched version that has children: those inherit from it. */
+      parents: Set<string>;
+      /** Child directories of removed or replaced versions that had children. */
+      childDirs: Set<string>;
+      /** Entries whose child directory changed in the source tree. */
+      containers: Set<string>;
+  }
+  /** 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>;
+  
+}
+
+declare module 'alinea/database/sync/SyncQueries' {
+
+  import type { EntryStatus } from 'alinea/core/Entry';
+  import type { Tree } from 'alinea/core/source/Tree';
+  import { type Database } from 'rado';
+  import { type entryIndexRow } from 'alinea/database/entry/EntryTable';
+  import type { EntrySyncTarget } from 'alinea/database/sync/EntrySyncer';
+  export const sqliteBatchSize = 5000;
+  /**
+   * Named parameters bypass column encoders, so bind SQLite values explicitly for
+   * the placeholders of {@link insertEntryQuery}.
+   */
+  export function insertEntryValues(row: ReturnType<typeof entryIndexRow>): {
+      versionId: string;
+      id: string;
+      locale: string | null;
+      versionStatus: EntryStatus;
+      status: EntryStatus;
+      type: string;
+      title: string;
+      workspace: string;
+      root: string;
+      sourceRoot: string | null;
+      parentId: string | null;
+      level: number;
+      index: string;
+      path: string;
+      filePath: string;
+      fileHash: string;
+      parentDir: string;
+      childrenDir: string;
+      url: string;
+      seeded: string | null;
+      rowHash: string;
+      childrenSha: string | null;
+      payload: string | null;
+      data: string;
+      parents: string;
+      active: number;
+      main: number;
+      visible: number;
+  };
+  export function prepareSyncQueries(db: Database, target: EntrySyncTarget, 
+  /** Store entry data as JSONB, on a SQLite that reads it. */
+  jsonb: boolean): {
+      revision: import("rado").PreparedQuery<{
+          revision: string;
+      }, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      tree: import("rado").PreparedQuery<{
+          tree: Tree;
+      }, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      setRevision: import("rado").PreparedQuery<import("rado/core/MetaData").MutationResultBase, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      entryCount: import("rado").PreparedQuery<{
+          value: number;
+      }, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      insertEntry: import("rado").PreparedQuery<import("rado/core/MetaData").MutationResultBase, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** Index the entry row inserted last, under its rowid. */
+      insertSearch: import("rado").PreparedQuery<import("rado/core/MetaData").MutationResultBase, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** Versions stored at these file paths or under these version ids. */
+      storedFiles: import("rado").PreparedQuery<{
+          id: string;
+          filePath: string;
+          childrenDir: string;
+          childrenSha: string | null;
+      }[], Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** Delete the versions stored at these file paths or version ids. */
+      deleteFiles: import("rado").PreparedQuery<import("rado/core/MetaData").MutationResultBase, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** Delete the search rows of those versions, before the versions. */
+      deleteSearch: import("rado").PreparedQuery<import("rado/core/MetaData").MutationResultBase, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      directories: import("rado").PreparedQuery<{
+          id: string;
+          childrenDir: string;
+          childrenSha: string | null;
+      }[], Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      updateChildrenSha: import("rado").PreparedQuery<import("rado/core/MetaData").MutationResultBase, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** Every version of these entries. */
+      versionsOf: import("rado").PreparedQuery<{
+          versionId: string;
+          id: string;
+          locale: string | null;
+          versionStatus: EntryStatus;
+          type: string;
+          index: string;
+          workspace: string;
+          root: string;
+          path: string;
+          filePath: string;
+          level: number;
+          parentDir: string;
+          childrenDir: string;
+          childrenSha: string | null;
+          parentId: string | null;
+          parents: string[];
+          status: EntryStatus;
+          active: boolean;
+          main: boolean;
+          visible: boolean;
+          url: string;
+      }[], Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** Every version stored below one directory. */
+      versionsBelow: import("rado").PreparedQuery<{
+          versionId: string;
+          id: string;
+          locale: string | null;
+          versionStatus: EntryStatus;
+          type: string;
+          index: string;
+          workspace: string;
+          root: string;
+          path: string;
+          filePath: string;
+          level: number;
+          parentDir: string;
+          childrenDir: string;
+          childrenSha: string | null;
+          parentId: string | null;
+          parents: string[];
+          status: EntryStatus;
+          active: boolean;
+          main: boolean;
+          visible: boolean;
+          url: string;
+      }[], Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** The entry owning each directory: children stored there have it as parent. */
+      owners: import("rado").PreparedQuery<{
+          childrenDir: string;
+          id: string;
+      }[], Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      statusesOf: import("rado").PreparedQuery<{
+          id: string;
+          locale: string | null;
+          status: EntryStatus;
+      }[], Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      dataOf: import("rado").PreparedQuery<{
+          versionId: string;
+          data: string;
+      }[], Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      updateVersion: import("rado").PreparedQuery<import("rado/core/MetaData").MutationResultBase, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** An entry whose versions disagree on what all of them must share. */
+      mismatchedEntry: import("rado").PreparedQuery<{
+          id: string;
+      }, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** A language whose versions disagree on their location. */
+      mismatchedLanguage: import("rado").PreparedQuery<{
+          id: string;
+          locale: string | null;
+      }, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** A language without exactly one active and one main version. */
+      invalidStatus: import("rado").PreparedQuery<{
+          id: string;
+          locale: string | null;
+      }, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      /** A version listed among its own parents. */
+      cyclicVersion: import("rado").PreparedQuery<{
+          filePath: string;
+      }, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
+      free(): void;
+  };
+  export type SyncQueries = ReturnType<typeof prepareSyncQueries>;
+  
+}
+
+declare module 'alinea/database/Version' {
+
+  /**
+   * Bump when the SQLite schema or the data derived into generated databases
+   * changes incompatibly. Generated database files and browser caches are keyed
+   * by this version rather than the package version, so releases that keep the
+   * schema reuse the databases that are already there.
+   */
+  export const databaseVersion = 5;
+  export const generatedDatabaseFile = "database-v5.sqlite";
+  export function versionedCacheName(name: string): string;
+  
+}
+
 declare module 'alinea/edit' {
 
   import type { Reference } from 'alinea/core/Reference';
@@ -9608,6 +10561,7 @@ declare module 'alinea/field/metadata/MetadataField' {
   import type { FieldOptions } from 'alinea/core/Field';
   import { RecordField } from 'alinea/core/field/RecordField';
   import { ScalarField } from 'alinea/core/field/ScalarField';
+  import { type Section, type SectionData } from 'alinea/core/Section';
   import { Type } from 'alinea/core/Type';
   import { type ImageField, type ImageLink } from 'alinea/field/link';
   import { type ObjectField } from 'alinea/field/object';
@@ -9620,19 +10574,23 @@ declare module 'alinea/field/metadata/MetadataField' {
   export interface MetadataUserOptions extends FieldOptions<MetadataAuditUser> {
       width?: number;
   }
-  export interface MetadataFields {
+  export interface MetadataSeoFields {
       title: TextField;
       description: TextField;
-      aliases: AliasesField;
       openGraph: ObjectField<{
           image: ImageField;
           title: TextField;
           description: TextField;
       }>;
+  }
+  export interface MetadataDetailsFields {
       createdAt: MetadataTimestampField;
       createdBy: MetadataUserField;
       updatedAt: MetadataTimestampField;
       updatedBy: MetadataUserField;
+      aliases: AliasesField;
+  }
+  export interface MetadataFields extends MetadataSeoFields, MetadataDetailsFields {
   }
   export interface MetadataAuditUser {
       name: string;
@@ -9654,6 +10612,15 @@ declare module 'alinea/field/metadata/MetadataField' {
   }
   export interface MetadataOptions extends FieldOptions<Metadata> {
       fields: Type<MetadataFields>;
+      seo: Type<MetadataSeoFields>;
+      details: Type<MetadataDetailsFields>;
+      /** The details are rendered by a separate `metadataDetails` section */
+      detailsSection?: boolean;
+  }
+  export interface MetadataConfig {
+      /** Leave the details out of the field view, render them with
+       * `metadataDetails(field)` instead */
+      detailsSection?: boolean;
   }
   export class MetadataField extends RecordField<Metadata, MetadataOptions> {
   }
@@ -9663,12 +10630,24 @@ declare module 'alinea/field/metadata/MetadataField' {
   }
   export class MetadataUserField extends ScalarField<MetadataAuditUser, MetadataUserOptions> {
   }
-  export function metadata(label?: string): MetadataField;
+  export function metadata(label?: string, { detailsSection }?: MetadataConfig): MetadataField;
+  export class MetadataDetailsSection implements SectionData {
+      field: MetadataField;
+      view: string;
+      definition: {};
+      fields: {};
+      sections: never[];
+      constructor(field: MetadataField);
+  }
+  /** Renders the created/updated details and aliases of a metadata field
+   * created with `detailsSection: true` */
+  export function metadataDetails(field: MetadataField): Section;
   
 }
 
 declare module 'alinea/field/metadata/MetadataField.view' {
 
+  import { Section } from 'alinea/core/Section';
   import { MetadataField, MetadataTimestampField, MetadataUserField } from 'alinea/field/metadata';
   export interface MetadataFieldViewProps {
       field: MetadataField;
@@ -9682,6 +10661,10 @@ 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 interface MetadataDetailsViewProps {
+      section: Section;
+  }
+  export function MetadataDetailsView({ section }: MetadataDetailsViewProps): import("react").JSX.Element;
   
 }
 
@@ -10112,7 +11095,7 @@ declare module 'alinea/field/richtext/RichTextExtensions' {
       Highlight: import("@tiptap/core").Mark<import("@tiptap/extension-highlight").HighlightOptions, any>;
       UndoRedo: Extension<import("@tiptap/extensions").UndoRedoOptions, any>;
   };
-  export function defaultExtensionConfig(getEntryAnchors?: () => Iterable<string>, enableImageResize?: boolean): {
+  export function defaultExtensionConfig(getEntryAnchors?: () => Iterable<string>, enableImageResize?: boolean, enableTables?: boolean): {
       Document: TipTapNode<any, any>;
       Text: TipTapNode<any, any>;
       Paragraph: TipTapNode<import("@tiptap/extension-paragraph").ParagraphOptions, any>;
@@ -10756,16 +11739,17 @@ declare module 'alinea' {
 
 declare module 'alinea/next' {
 
-  export { createCMS } from 'alinea/adapter/next/cms';
-  export { createHandler, type NextHandlerOptions } from 'alinea/adapter/next/handler';
-  export type { AfterCommitContext, BeforeCommitContext } from 'alinea/backend/Handler';
+  export type { SyncStatus } from 'alinea/adapter/next/cms';
+  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 { AfterCommitContext, BeforeCommitContext } from 'alinea/backend/Handler';
   
 }
 
 declare module 'alinea/next.edge' {
 
-  export { createCMS } from 'alinea/adapter/next/cms';
+  export { createCMS, type SyncStatus } from 'alinea/adapter/next/cms';
   export { createHandler, type NextHandlerOptions } from 'alinea/adapter/next/handler';
   export type { AfterCommitContext, BeforeCommitContext } from 'alinea/backend/Handler';
   
@@ -10978,6 +11962,20 @@ declare module 'alinea/preview/RegisterPreview' {
 declare module 'alinea/preview/widget' {
 
   import type { DOMAttributes } from 'react';
+  export interface PreviewStat {
+      kind: 'query' | 'sync';
+      summary: string;
+      /** Whether the query was answered by the bundled database or the handler. */
+      source?: 'database' | 'handler';
+      durationMs: number;
+  }
+  /** The CMS work of one render, shown in the widget. */
+  export interface PreviewStats {
+      rows: Array<PreviewStat>;
+      /** SQL statements run in this process for the render. */
+      statements: number;
+      sqlMs: number;
+  }
   export function registerPreviewWidget(): void;
   global {
       namespace JSX {
@@ -10986,6 +11984,8 @@ declare module 'alinea/preview/widget' {
                   adminUrl: string;
                   editUrl: string;
                   livePreview?: 'connected' | 'warning' | 'loading';
+                  /** JSON encoded PreviewStats */
+                  stats?: string;
               };
           }
       }
@@ -11019,7 +12019,11 @@ declare module 'alinea/query' {
       count?: true;
       id?: import("alinea/core/Filter").Condition<string>;
       parentId?: import("alinea/core/Filter").Condition<string | null>;
+      versionStatus?: import("alinea/core/Filter").Condition<import("alinea/core/Entry").EntryStatus>;
+      main?: import("alinea/core/Filter").Condition<boolean>;
       path?: import("alinea/core/Filter").Condition<string>;
+      filePath?: import("alinea/core/Filter").Condition<string>;
+      seeded?: import("alinea/core/Filter").Condition<string | null>;
       url?: import("alinea/core/Filter").Condition<string>;
       alias?: import("alinea/core/Filter").Condition<string>;
       createdAt?: import("alinea/core/Filter").Condition<number | null>;
@@ -11054,7 +12058,11 @@ declare module 'alinea/query' {
       count?: true;
       id?: import("alinea/core/Filter").Condition<string>;
       parentId?: import("alinea/core/Filter").Condition<string | null>;
+      versionStatus?: import("alinea/core/Filter").Condition<import("alinea/core/Entry").EntryStatus>;
+      main?: import("alinea/core/Filter").Condition<boolean>;
       path?: import("alinea/core/Filter").Condition<string>;
+      filePath?: import("alinea/core/Filter").Condition<string>;
+      seeded?: import("alinea/core/Filter").Condition<string | null>;
       url?: import("alinea/core/Filter").Condition<string>;
       alias?: import("alinea/core/Filter").Condition<string>;
       createdAt?: import("alinea/core/Filter").Condition<number | null>;
@@ -11089,7 +12097,11 @@ declare module 'alinea/query' {
       count?: true;
       id?: import("alinea/core/Filter").Condition<string>;
       parentId?: import("alinea/core/Filter").Condition<string | null>;
+      versionStatus?: import("alinea/core/Filter").Condition<import("alinea/core/Entry").EntryStatus>;
+      main?: import("alinea/core/Filter").Condition<boolean>;
       path?: import("alinea/core/Filter").Condition<string>;
+      filePath?: import("alinea/core/Filter").Condition<string>;
+      seeded?: import("alinea/core/Filter").Condition<string | null>;
       url?: import("alinea/core/Filter").Condition<string>;
       alias?: import("alinea/core/Filter").Condition<string>;
       createdAt?: import("alinea/core/Filter").Condition<number | null>;
@@ -11124,7 +12136,11 @@ declare module 'alinea/query' {
       count?: true;
       id?: import("alinea/core/Filter").Condition<string>;
       parentId?: import("alinea/core/Filter").Condition<string | null>;
+      versionStatus?: import("alinea/core/Filter").Condition<import("alinea/core/Entry").EntryStatus>;
+      main?: import("alinea/core/Filter").Condition<boolean>;
       path?: import("alinea/core/Filter").Condition<string>;
+      filePath?: import("alinea/core/Filter").Condition<string>;
+      seeded?: import("alinea/core/Filter").Condition<string | null>;
       url?: import("alinea/core/Filter").Condition<string>;
       alias?: import("alinea/core/Filter").Condition<string>;
       createdAt?: import("alinea/core/Filter").Condition<number | null>;
@@ -11157,7 +12173,11 @@ declare module 'alinea/query' {
       count?: true;
       id?: import("alinea/core/Filter").Condition<string>;
       parentId?: import("alinea/core/Filter").Condition<string | null>;
+      versionStatus?: import("alinea/core/Filter").Condition<import("alinea/core/Entry").EntryStatus>;
+      main?: import("alinea/core/Filter").Condition<boolean>;
       path?: import("alinea/core/Filter").Condition<string>;
+      filePath?: import("alinea/core/Filter").Condition<string>;
+      seeded?: import("alinea/core/Filter").Condition<string | null>;
       url?: import("alinea/core/Filter").Condition<string>;
       alias?: import("alinea/core/Filter").Condition<string>;
       createdAt?: import("alinea/core/Filter").Condition<number | null>;
@@ -11189,7 +12209,11 @@ declare module 'alinea/query' {
       count?: true;
       id?: import("alinea/core/Filter").Condition<string>;
       parentId?: import("alinea/core/Filter").Condition<string | null>;
+      versionStatus?: import("alinea/core/Filter").Condition<import("alinea/core/Entry").EntryStatus>;
+      main?: import("alinea/core/Filter").Condition<boolean>;
       path?: import("alinea/core/Filter").Condition<string>;
+      filePath?: import("alinea/core/Filter").Condition<string>;
+      seeded?: import("alinea/core/Filter").Condition<string | null>;
       url?: import("alinea/core/Filter").Condition<string>;
       alias?: import("alinea/core/Filter").Condition<string>;
       createdAt?: import("alinea/core/Filter").Condition<number | null>;
@@ -11221,7 +12245,11 @@ declare module 'alinea/query' {
       count?: true;
       id?: import("alinea/core/Filter").Condition<string>;
       parentId?: import("alinea/core/Filter").Condition<string | null>;
+      versionStatus?: import("alinea/core/Filter").Condition<import("alinea/core/Entry").EntryStatus>;
+      main?: import("alinea/core/Filter").Condition<boolean>;
       path?: import("alinea/core/Filter").Condition<string>;
+      filePath?: import("alinea/core/Filter").Condition<string>;
+      seeded?: import("alinea/core/Filter").Condition<string | null>;
       url?: import("alinea/core/Filter").Condition<string>;
       alias?: import("alinea/core/Filter").Condition<string>;
       createdAt?: import("alinea/core/Filter").Condition<number | null>;