alinea 2.0.0-preview.8 → 2.0.0-preview.9

package/dist/bundled.d.ts

@@ -93,14 +93,6 @@ declare module 'alinea/adapter/next/context' {
   
 }
 
-declare module 'alinea/adapter/next/DevRemote' {
-
-  import type { RemoteConnection, RequestContext } from 'alinea/core/Connection';
-  import type { Config } from 'alinea/core/Config';
-  export function createDevRemote(context: RequestContext, config: Config): RemoteConnection;
-  
-}
-
 declare module 'alinea/adapter/next/ForwardCredentials' {
 
   export function forwardDevelopmentCredentials(request: Request | undefined, apiKey: string, init?: RequestInit): RequestInit;
@@ -167,16 +159,32 @@ 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';
+  import type { PreviewDatabase, PreviewStat, PreviewStatement, 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;
+      slowest: Array<PreviewStatement>;
+      /** The bundled database that answered, once a query reached it. */
+      database?: PreviewDatabase;
+      readonly startedAt: 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;
+      /**
+       * Time a database query without the time it waited behind the others:
+       * queries of a render run one at a time in the order they were called, so
+       * one starts executing once the previous one finished, or when it was
+       * called if that is later.
+       */
+      executed<T>(row: PreviewStat, run: () => Promise<T>): Promise<T>;
+      /**
+       * Count a statement towards the render, and towards the row that ran it:
+       * a sync in progress, or else the query executing, which is the earliest
+       * one called that has not finished (see `executed`).
+       */
+      statement(durationMs: number, sql?: string): void;
       /**
        * Resolves once nothing ran for `quietMs`, so queries of server components
        * that render after the caller are counted, or after `maxMs` regardless.
@@ -184,8 +192,13 @@ declare module 'alinea/adapter/next/renderStats' {
       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.
+   * A statement short enough to read in a table, such as
+   * `select … from alinea_entry_index where (visible = ? and id in (?))`.
+   */
+  export function summarizeSql(sql: string, maxLength?: number): string;
+  /**
+   * Time the work a row stands for from call to answer, such as a sync or a
+   * query the handler answers, 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)`. */
@@ -422,9 +435,8 @@ declare module 'alinea/backend/api/OAuth2' {
 
 declare module 'alinea/backend/api/ProxyMedia' {
 
-  import { type Request, Response } from '@alinea/iso';
-  export function proxyMediaUrl(request: Request, source: URL, isAllowed?: (url: URL) => boolean): Promise<Response>;
-  export function isRedirectStatus(status: number): boolean;
+  import { type Request } from '@alinea/iso';
+  export function proxyMediaUrl(request: Request, source: URL): Promise<Response>;
   
 }
 
@@ -562,7 +574,7 @@ declare module 'alinea/backend/HandleAction' {
       Mutate = "mutate",
       Upload = "upload",
       Tree = "tree",
-      Commit = "commit",
+      Sha = "sha",
       Blob = "blob"
   }
   
@@ -806,10 +818,13 @@ declare module 'alinea/backend/router/Router' {
 declare module 'alinea/backend/store/GeneratedDatabase' {
 
   import type { Config } from 'alinea/core/Config';
+  import type { DatabaseHandle } from 'alinea/database/driver/DatabaseHandle';
   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>;
+  /**
+   * Serve a generated database from a connection that keeps its writes in
+   * memory, so syncs and commits never reach the generated file.
+   */
+  export function createGeneratedDatabase(config: Config, { database: db, fork, driver }: DatabaseHandle): Promise<EntryStore>;
   
 }
 
@@ -817,7 +832,7 @@ declare module 'alinea/backend/store/GeneratedDatabaseNode' {
 
   import type { Config } from 'alinea/core/Config';
   import type { DatabaseOptions } from 'rado';
-  /** Open the traced generated file through the native SQLite driver. */
+  /** Open the traced generated file as an in-memory overlay. */
   export function generatedDatabase(config: Config, options?: DatabaseOptions): Promise<import("alinea/database/EntryStore").EntryStore>;
   
 }
@@ -1080,6 +1095,7 @@ declare module 'alinea/cli/serve/CreateLocalServer' {
 
 declare module 'alinea/cli/serve/DevServer' {
 
+  import type { CMS } from 'alinea/core/CMS';
   import { Config } from 'alinea/core/Config';
   import { Request, type Response } from '@alinea/iso';
   import type { BuildOptions } from 'esbuild';
@@ -1100,6 +1116,7 @@ declare module 'alinea/cli/serve/DevServer' {
       handle(input: Request): Promise<Response>;
   }
   export function createDevServer(dir: string, options: CreateDevServerOptions): Promise<DevServer>;
+  export function forwardMutation(request: Request, cms: CMS, apiKey: string): Promise<Response | undefined>;
   
 }
 
@@ -2209,7 +2226,6 @@ declare module 'alinea/core/Client' {
   import { type AuthResult } from 'alinea/cloud/AuthResult';
   import type { Config } from 'alinea/core/Config';
   import type { BackendCapabilities, LocalConnection, Revision, UploadMetadata, UploadResponse } from 'alinea/core/Connection';
-  import type { CommitRequest } from 'alinea/core/db/CommitRequest';
   import type { Mutation } from 'alinea/core/db/Mutation';
   import type { Draft, DraftKey } from 'alinea/core/Draft';
   import type { EntryRecord } from 'alinea/core/EntryRecord';
@@ -2246,10 +2262,8 @@ declare module 'alinea/core/Client' {
       revisions(file: string): Promise<Array<Revision>>;
       revisionData(file: string, revisionId: string): Promise<EntryRecord | undefined>;
       getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
+      getSha(): Promise<string>;
       getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
-      write(request: CommitRequest): Promise<{
-          sha: string;
-      }>;
       getDraft(key: DraftKey): Promise<Draft | undefined>;
       storeDraft(draft: Draft): Promise<void>;
   }
@@ -2383,7 +2397,8 @@ declare module 'alinea/core/Connection' {
   export interface BrowserConnection extends Connection {
       logout?(): Promise<void>;
   }
-  export interface LocalConnection extends Connection, CapabilitiesApi {
+  /** A handler seen from the dashboard or an app: it commits by mutating. */
+  export interface LocalConnection extends SyncApi, HistoryApi, DraftsApi, UploadsApi, UserApi, CapabilitiesApi {
       mutate(mutations: Array<Mutation>): Promise<{
           sha: string;
       }>;
@@ -2422,6 +2437,8 @@ declare module 'alinea/core/Connection' {
       applyAuth?(init?: RequestInit): RequestInit;
   }
   export const developmentKeyHeader = "x-alinea-dev-key";
+  /** Marks a mutation an app sends back to the dev server after its hooks ran. */
+  export const forwardedMutationHeader = "x-alinea-forwarded";
   export interface AuthedContext extends RequestContext {
       user: User;
       token: string;
@@ -2614,6 +2631,8 @@ declare module 'alinea/core/db/LocalStore' {
    */
   export interface LocalStore extends WriteableGraph, RemoteSource {
       source: Source;
+      /** How the store reads its database, when it is a SQLite connection. */
+      driver?: 'native' | 'overlay' | 'wasm';
       sha: string | Promise<string>;
       sync(): Promise<string>;
       syncWith(remote: RemoteSource, options?: SyncOptions): Promise<string>;
@@ -8038,7 +8057,7 @@ declare module 'alinea/dashboard/boot/LoadWorker' {
 declare module 'alinea/dashboard/boot/WorkerDB' {
 
   import type { Config } from 'alinea/core/Config';
-  import type { Connection, UploadMetadata, UploadResponse } from 'alinea/core/Connection';
+  import type { LocalConnection, UploadMetadata, UploadResponse } from 'alinea/core/Connection';
   import type { AnyQueryResult, GraphQuery } from 'alinea/core/Graph';
   import type { EntryReferenceQuery, EntryReferenceResult } from 'alinea/core/db/EntryReference';
   import type { Mutation } from 'alinea/core/db/Mutation';
@@ -8049,7 +8068,7 @@ declare module 'alinea/dashboard/boot/WorkerDB' {
       #private;
       config: Config;
       events: EventTarget;
-      constructor(config: Config, worker: DashboardWorker, client: Connection, events: EventTarget);
+      constructor(config: Config, worker: DashboardWorker, client: LocalConnection, events: EventTarget);
       mutate(mutations: Array<Mutation>): Promise<{
           id: string;
           sha: string;
@@ -8727,14 +8746,25 @@ declare module 'alinea/database/BrowserEntryStore' {
   import type { RemoteSource } from 'alinea/core/source/Source';
   import { EntryStore } from 'alinea/database/EntryStore';
   export interface BrowserEntryStoreOptions {
-      indexedDB: IDBFactory;
       name: string;
       revision: string;
+      /**
+       * The store this one replaces, such as one of a previous dashboard build:
+       * its content carries over from memory instead of loading it again, and it
+       * stops storing without waiting for its work in flight.
+       */
+      replaces?: BrowserEntryStore;
+      /** The IndexedDB implementation, the global one by default. */
+      indexedDB?: IDBFactory;
+      IDBKeyRange?: typeof IDBKeyRange;
   }
-  /** WASM entry store persisted as one SQLite file in IndexedDB. */
+  /**
+   * WASM entry store kept in IndexedDB: every commit stores the pages it
+   * changed.
+   */
   export class BrowserEntryStore extends EntryStore {
       #private;
-      static open(config: Config, options: BrowserEntryStoreOptions): Promise<BrowserEntryStore>;
+      static open(config: Config, options: BrowserEntryStoreOptions, retried?: boolean): Promise<BrowserEntryStore>;
       private constructor();
       sync(): Promise<string>;
       syncWith(remote: RemoteSource, options?: SyncOptions): Promise<string>;
@@ -8745,9 +8775,10 @@ declare module 'alinea/database/BrowserEntryStore' {
           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. */
+      /**
+       * Close a store that a replacement took over from: its work in flight
+       * changes only its memory copy, which is not stored.
+       */
       abandon(): Promise<void>;
   }
   
@@ -8758,11 +8789,11 @@ 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';
+  import type { EntryDatabase } from 'alinea/database/EntryDatabase';
   /** Read-only Source view backed by exact payload text in an entry database. */
   export class DatabaseSource implements Source {
       #private;
-      constructor(database: EntryLayer);
+      constructor(database: EntryDatabase);
       getTree(): Promise<ReadonlyTree>;
       getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
       getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array<ArrayBufferLike>], any, any>;
@@ -8814,28 +8845,89 @@ declare module 'alinea/database/DatabaseTables' {
   
 }
 
+declare module 'alinea/database/driver/DatabaseHandle' {
+
+  import type { Database } from 'rado';
+  /**
+   * How a connection reads its data: a native file, a native in-memory overlay
+   * of a file, or a copy in WASM memory.
+   */
+  export type DatabaseDriver = 'native' | 'overlay' | 'wasm';
+  /** A SQLite connection, which may copy itself without copying its data. */
+  export interface DatabaseHandle {
+      database: Database;
+      driver?: DatabaseDriver;
+      /**
+       * An independent connection to the last committed state. The copy shares
+       * every page with this one until either side writes it. Connections that
+       * write a file in place cannot fork.
+       */
+      fork?(): Promise<DatabaseHandle>;
+  }
+  
+}
+
+declare module 'alinea/database/driver/OverlayExtension.browser' {
+
+  /** Browser bundles reach the database driver without ever running it. */
+  export function overlayExtension(): string;
+  
+}
+
+declare module 'alinea/database/driver/OverlayExtension' {
+
+  export { overlayExtension } from '@alinea/sqlite-wasm/native';
+  
+}
+
 declare module 'alinea/database/driver/RuntimeDatabase' {
 
-  import type { Database, DatabaseOptions } from 'rado';
+  import type { DatabaseOptions } from 'rado';
+  import type { DatabaseHandle } from 'alinea/database/driver/DatabaseHandle';
   export interface RuntimeDatabaseOptions extends DatabaseOptions {
-      path?: string;
-      data?: Uint8Array;
-      readonly?: boolean;
+      path: string;
+      /** Keep every write in memory: the file is never written. */
+      overlay?: boolean;
   }
-  /** Select a native Node/Bun driver for files and WASM for byte buffers. */
-  export function runtimeDatabase(options?: RuntimeDatabaseOptions): Promise<Database>;
+  /**
+   * Open a SQLite file with the native Node/Bun driver. Overlays of the file
+   * keep their writes in memory and fork cheaply, through the native overlay
+   * VFS or else a WASM copy; a file opened for writing cannot fork.
+   */
+  export function runtimeDatabase(options: RuntimeDatabaseOptions): Promise<DatabaseHandle>;
   
 }
 
 declare module 'alinea/database/driver/WasmDatabase' {
 
+  import type { Storage } from '@alinea/sqlite-wasm/Database.js';
+  import type { DatabaseOptions } from 'rado';
   import { connect } from 'rado/driver/sql.js';
-  export interface WasmDatabaseHandle {
+  import type { DatabaseHandle } from 'alinea/database/driver/DatabaseHandle';
+  export interface WasmDatabaseHandle extends DatabaseHandle {
       database: ReturnType<typeof connect>;
+      fork(): Promise<WasmDatabaseHandle>;
       export(): Uint8Array;
+      /** Resolves once every commit so far is stored; at once in memory. */
+      flush(): Promise<void>;
+      /**
+       * Store this database from now on, replacing what the storage held, once
+       * a database detached from it wrote its last commits.
+       */
+      attach(storage: Storage): Promise<void>;
+      /**
+       * Stop storing commits once the ones so far are written; later commits
+       * change only the memory copy.
+       */
+      detach(): void;
   }
+  /**
+   * Open a WASM connection from the database kept in storage, or an empty one,
+   * that stores every commit there.
+   */
+  export function syncWasmDatabase(storage: Storage, options?: DatabaseOptions): Promise<WasmDatabaseHandle>;
   /** Open an in-memory WASM connection, optionally from a complete SQLite file. */
-  export function openWasmDatabase(data?: Uint8Array): Promise<WasmDatabaseHandle>;
+  export function openWasmDatabase(data?: Uint8Array, options?: DatabaseOptions): Promise<WasmDatabaseHandle>;
   export function wasmDatabase(data?: Uint8Array): Promise<import("rado").SyncDatabase<"sqlite">>;
   
 }
@@ -8860,13 +8952,14 @@ declare module 'alinea/database/entry/EntryData' {
 
 declare module 'alinea/database/entry/EntryTable' {
 
+  import type { Config } from 'alinea/core/Config';
   import type { Entry, EntryStatus } from 'alinea/core/Entry';
-  import { type Table } from 'rado';
+  import { type Database, 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.
+       * keeps it.
        */
       rowid: import("rado").Column<number, [false, false]>;
       versionId: import("rado").Column<string, [false, boolean]>;
@@ -8905,10 +8998,10 @@ declare module 'alinea/database/entry/EntryTable' {
        */
       data: import("rado").Column<string, [false, boolean]>;
   };
-  export function entryIndexTable(name: string, temporary?: boolean): Table<{
+  export function entryIndexTable(name: string): Table<{
       /**
        * Also the rowid of the version's full-text search row. Declared, so VACUUM
-       * and copies into overlay tables keep it.
+       * keeps it.
        */
       rowid: import("rado").Column<number, [false, false]>;
       versionId: import("rado").Column<string, [false, boolean]>;
@@ -8951,7 +9044,7 @@ declare module 'alinea/database/entry/EntryTable' {
   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.
+       * keeps it.
        */
       rowid: import("rado").Column<number, [false, false]>;
       versionId: import("rado").Column<string, [false, boolean]>;
@@ -8990,6 +9083,21 @@ declare module 'alinea/database/entry/EntryTable' {
        */
       data: import("rado").Column<string, [false, boolean]>;
   }, string>;
+  /** The entry ids each entry version references, under the version's rowid. */
+  export const EntryReferenceTable: Table<{
+      targetId: import("rado").Column<string, [false, boolean]>;
+      source: import("rado").Column<number, [false, boolean]>;
+  }, "alinea_entry_reference">;
+  /** Fields whose queries order by their stored value, through a field index. */
+  export function isOrderedField(field: unknown): boolean;
+  /** Metadata fields whose queries order by their stored value. */
+  export const orderedMetadata: Set<string>;
+  /**
+   * Index the stored value of every ordered field in the config, per type, and
+   * of the ordered metadata. Field names are identifiers, so the dotted metadata
+   * names cannot collide with them.
+   */
+  export function syncFieldIndexes(db: Database, config: Config): Promise<void>;
   /** An Entry plus the physical-version and local-index fields. */
   export interface IndexedEntry extends Entry {
       versionStatus: EntryStatus;
@@ -9036,93 +9144,29 @@ declare module 'alinea/database/entry/EntryTable' {
   
 }
 
-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 type { Mutation } from 'alinea/core/db/Mutation';
   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 { FileStat } from 'alinea/core/source/FSSource';
   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;
-  }
+  import type { DatabaseHandle } from 'alinea/database/driver/DatabaseHandle';
   export interface EntryDatabaseOptions {
       includedAtBuild?(filePath: string): boolean | Promise<boolean>;
+      /** Copy the connection for an overlay; without it there are none. */
+      fork?(): Promise<DatabaseHandle>;
+      /**
+       * Whether syncs record the source tree in the state, so the database can be
+       * reopened and synced from it. An overlay keeps its tree in memory.
+       */
+      recordsTree?: boolean;
   }
   export interface EntryApplyOptions {
       source: Source;
@@ -9137,52 +9181,67 @@ declare module 'alinea/database/EntryLayer' {
   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 {
+  /**
+   * A queryable entry index owning its SQLite connection. Mutations are planned
+   * on a working copy inside a write transaction of that connection.
+   */
+  export class EntryDatabase extends Graph implements AsyncDisposable {
       #private;
-      constructor(config: Config, options: EntryDatabaseOptions, state: EntryLayerState);
+      constructor(config: Config, db: Database, options?: EntryDatabaseOptions);
       get config(): Config;
+      /** Whether this database can create overlays. */
+      get forkable(): boolean;
       includedAtBuild(filePath: string): boolean | Promise<boolean>;
-      /** Whether this layer was closed, and answers only from a replacement. */
+      /** Whether this database 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.
+       * Run a task while no other task uses the connection, so no transaction
+       * is open: a fork of the connection then copies committed state.
+       */
+      whileIdle<T>(task: () => Promise<T>): Promise<T>;
+      /**
+       * Fork the connection and synchronize the copy with a source. The overlay
+       * shares every unchanged page with this database and is independent of it:
+       * either can change or close without affecting the other.
+       */
+      overlay(source: RemoteSource): Promise<EntryDatabase>;
+      static createSchema(db: Database, config: Config, revision: string, configFingerprint?: string): Promise<void>;
+      /**
+       * Synchronize a source through this database'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.
+       * database stores, recording the fingerprint so a later open recognizes the
+       * database as written by that config. The rows of the previous config are
+       * replaced within one transaction, so reads keep answering from them until
+       * the replacement is committed.
        */
-      protected reindexEntries(config: Config, reset?: (tx: Database) => Promise<void>): Promise<EntrySyncResult>;
-      /** Atomically plan and apply mutations through a private working layer. */
+      reindex(config: Config, configFingerprint?: string): Promise<EntrySyncResult>;
+      /** Atomically plan and apply mutations through a private working copy. */
       apply(mutations: ReadonlyArray<Mutation>, options: EntryApplyOptions): Promise<EntryApplyResult>;
       /** Plan mutations like apply, then roll them back. */
       plan(mutations: ReadonlyArray<Mutation>, options: EntryApplyOptions): Promise<CommitRequest>;
+      /**
+       * Resolve a query with a source synced into this database, within a write
+       * transaction that is rolled back afterwards.
+       */
+      resolveWith<const Query extends GraphQuery>(source: RemoteSource, query: Query): Promise<AnyQueryResult<Query>>;
       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;
+      /** 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>;
   }
   
 }
@@ -9200,39 +9259,37 @@ declare module 'alinea/database/EntryStore' {
   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';
+  import { EntryDatabase, type EntryChangeListener } from 'alinea/database/EntryDatabase';
+  import type { DatabaseDriver } from 'alinea/database/driver/DatabaseHandle';
   export interface EntryStoreOptions {
       ownsDatabase?: boolean;
       sourceFollowsDatabase?: boolean;
-      close?: () => Promise<void>;
+      driver?: DatabaseDriver;
   }
   /** 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 database: EntryDatabase;
       readonly source: Source;
-      constructor(config: Config, database: EntryLayer, source: Source, options?: EntryStoreOptions);
+      readonly driver?: DatabaseDriver;
+      constructor(config: Config, database: EntryDatabase, 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.
+       * Preview queries resolve over the store with the previewed entry synced
+       * in. The last payload keeps its fork, so repeated queries of one preview
+       * sync once; another payload or store revision forks afresh. A database
+       * that cannot fork syncs each preview in a transaction it rolls back.
        */
       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<{
@@ -9260,7 +9317,7 @@ declare module 'alinea/database/EntryTransaction' {
   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';
+  import type { EntryDatabase } from 'alinea/database/EntryDatabase';
   type Op<T> = Omit<T, 'op'>;
   /**
    * Plans mutations inside the receiver's write transaction. Each mutation is
@@ -9269,8 +9326,8 @@ declare module 'alinea/database/EntryTransaction' {
    */
   export class EntryTransaction implements AsyncDisposable {
       #private;
-      /** @internal Constructed by EntryLayer.apply. */
-      constructor(workingDatabase: EntryLayer, workingSource: OverlaySource, sourceTransaction: SourceTransaction, from: ReadonlyTree, policy: Policy);
+      /** @internal Constructed by EntryDatabase.apply. */
+      constructor(workingDatabase: EntryDatabase, 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>;
@@ -9362,7 +9419,7 @@ declare module 'alinea/database/query/EntryQuery' {
   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';
+  import { searchQuery } from 'alinea/database/query/Search';
   interface RelationProjection {
       path: Array<string>;
       plan: ProjectionPlan;
@@ -9392,7 +9449,8 @@ declare module 'alinea/database/query/EntryQuery' {
       entry?: EntryIndexTarget;
       depth?: number;
       baseEntry?: EntryIndexTarget;
-      searchTable?: EntrySearchTarget;
+      /** Wrap every row and carry its entry id next to the selection. */
+      withId?: boolean;
   }
   export function compileEntryQuery(config: Config, query: GraphQuery, options?: EntryQueryOptions): {
       rows: import("rado").Select<SelectionInput, import("rado/core/MetaData").QueryMeta>;
@@ -9407,9 +9465,8 @@ 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>;
+  /** Read the versions indexed as referencing the target and walk their data. */
+  export function queryEntryReferences(config: Config, db: Database, query: EntryReferenceQuery): Promise<EntryReferenceResult>;
   
 }
 
@@ -9434,14 +9491,11 @@ 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';
+  import type { 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>;
   }
@@ -9451,20 +9505,13 @@ declare module 'alinea/database/query/ResolveQuery' {
 
 declare module 'alinea/database/query/Search' {
 
-  import { type Database, type HasSql, type Sql, type Table } from 'rado';
+  import { type Database, type HasSql, type Sql } 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: {
+  export const EntrySearchTable: import("rado").Table<{
       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;
+  }, "alinea_entry_search">;
   export interface SearchQuery {
       target: Sql;
       identity: Sql<boolean>;
@@ -9472,32 +9519,30 @@ declare module 'alinea/database/query/Search' {
       rank: Sql<number>;
       snippet(start: HasSql, end: HasSql, cutOff: HasSql, limit: HasSql): Sql<string>;
   }
-  export function createSearch(db: Database, search: EntrySearchTarget): Promise<void>;
+  export function createSearch(db: Database): 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 searchableText(entry: EntryIndexTarget): 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;
+  export function searchQuery(input: string | Array<string> | undefined, entry: EntryIndexTarget, 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
+   * The terms of the search index, 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>;
+      load(db: Database, 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 {};
   
 }
 
@@ -9518,8 +9563,12 @@ declare module 'alinea/database/sync/EntryParser' {
 
   import type { Config } from 'alinea/core/Config';
   import type { IndexedEntry } from 'alinea/database/entry/EntryTable';
+  /** A parsed source entry and the ids of the entries it references. */
+  export interface ParsedEntry extends IndexedEntry {
+      references: Array<string>;
+  }
   /** 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;
+  export function parseSourceEntry(config: Config, filePath: string, fileHash: string, blob: Uint8Array): ParsedEntry;
   
 }
 
@@ -9528,27 +9577,17 @@ 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;
+  import type { Database } from 'rado';
   export interface EntrySyncOptions {
       previousTree?: ReadonlyTree;
       withinTransaction?: boolean;
       /** Skip entry validation for a source whose entries were already validated. */
       validate?: boolean;
+      /**
+       * Record the synced source tree in the state, so the database can be
+       * reopened and synced from it. Defaults to true.
+       */
+      recordsTree?: boolean;
   }
   /** Prepared, serialized source synchronization for one database connection. */
   export class EntrySyncer {
@@ -9557,9 +9596,7 @@ declare module 'alinea/database/sync/EntrySyncer' {
       /** 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>;
+      sync(source: RemoteSource, tree: ReadonlyTree, fromRevision: string, options?: EntrySyncOptions): Promise<Array<string>>;
       close(): Promise<void>;
   }
   
@@ -9597,7 +9634,6 @@ declare module 'alinea/database/sync/SyncQueries' {
   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
@@ -9633,7 +9669,7 @@ declare module 'alinea/database/sync/SyncQueries' {
       main: number;
       visible: number;
   };
-  export function prepareSyncQueries(db: Database, target: EntrySyncTarget, 
+  export function prepareSyncQueries(db: Database, 
   /** Store entry data as JSONB, on a SQLite that reads it. */
   jsonb: boolean): {
       revision: import("rado").PreparedQuery<{
@@ -9649,6 +9685,8 @@ declare module 'alinea/database/sync/SyncQueries' {
       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>;
+      /** Record the entry ids a version references, under its rowid. */
+      insertReferences: 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;
@@ -9660,6 +9698,8 @@ declare module 'alinea/database/sync/SyncQueries' {
       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>;
+      /** Delete the reference rows of those versions, before the versions. */
+      deleteReferences: import("rado").PreparedQuery<import("rado/core/MetaData").MutationResultBase, Record<string, unknown>, import("rado/core/MetaData").QueryMeta>;
       directories: import("rado").PreparedQuery<{
           id: string;
           childrenDir: string;
@@ -9761,8 +9801,8 @@ declare module 'alinea/database/Version' {
    * 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 const databaseVersion = 8;
+  export const generatedDatabaseFile = "database-v8.sqlite";
   export function versionedCacheName(name: string): string;
   
 }
@@ -11967,7 +12007,32 @@ declare module 'alinea/preview/widget' {
       summary: string;
       /** Whether the query was answered by the bundled database or the handler. */
       source?: 'database' | 'handler';
+      /**
+       * Execution time for queries the bundled database answers, without the
+       * wait behind the render's other queries; time from call to answer for
+       * syncs and queries the handler answers.
+       */
+      durationMs: number;
+      /** SQL statements this row's work ran, such as a preview's sync. */
+      statements?: number;
+      sqlMs?: number;
+  }
+  /** One of the slowest SQL statements of a render. */
+  export interface PreviewStatement {
+      /** The statement, shortened */
+      sql: string;
       durationMs: number;
+      /** Summary of the query or sync that ran it */
+      query?: string;
+  }
+  /** The bundled database that answered the render's queries. */
+  export interface PreviewDatabase {
+      /** The native overlay, the native file, or the WASM copy */
+      driver?: string;
+      /** Time this process took to open it */
+      openMs: number;
+      /** Whether this render waited for it to open */
+      cold: boolean;
   }
   /** The CMS work of one render, shown in the widget. */
   export interface PreviewStats {
@@ -11975,6 +12040,10 @@ declare module 'alinea/preview/widget' {
       /** SQL statements run in this process for the render. */
       statements: number;
       sqlMs: number;
+      /** Time from the first query or sync of the render until the last settled. */
+      renderMs: number;
+      slowest?: Array<PreviewStatement>;
+      database?: PreviewDatabase;
   }
   export function registerPreviewWidget(): void;
   global {