latticesql 4.3.8 → 5.0.0

package/dist/index.d.cts

@@ -54,10 +54,40 @@ interface RenderCursor {
     grants: string | null;
     owners: string | null;
 }
+/** A rendered file Lattice wrote outside the entity-context trees (a phase-1
+ *  table rollup), tracked so it has a lifecycle: when its path changes or its
+ *  table disappears, the old path moves to `retiredFiles` and is pruned by the
+ *  next reconciliation — hash-guarded so a user-edited file is never deleted. */
+interface TableFileManifestInfo {
+    /** Path relative to the output dir (the compiled def.outputFile). */
+    path: string;
+    /** SHA-256 hex digest of the last content Lattice rendered to it. */
+    hash: string;
+}
 interface LatticeManifest {
     version: 1 | 2;
     generated_at: string;
     entityContexts: Record<string, EntityContextManifestEntry>;
+    /**
+     * Phase-1 table rollup files, keyed by table (see {@link TableFileManifestInfo}).
+     * Optional — a v3 manifest has no rollup history, and reconciliation treats the
+     * absence as "prune nothing" (never as delete-everything).
+     */
+    tableFiles?: Record<string, TableFileManifestInfo>;
+    /**
+     * Phase-2 multi-output files, keyed by multi name: every path the multi
+     * produced on its last render, with content hashes. A key that disappears (a
+     * deleted row) retires its path into `retiredFiles` on the next render.
+     */
+    multiFiles?: Record<string, Record<string, string>>;
+    /**
+     * Rendered files whose path is no longer produced by the current schema (an
+     * outputFile change, a dropped table). Each entry persists here until the
+     * reconciliation pass actually deletes it (only when the on-disk content still
+     * hashes to Lattice's own last write) or the file disappears — so a crash
+     * between the manifest write and the prune can never orphan a file forever.
+     */
+    retiredFiles?: TableFileManifestInfo[];
     /**
      * Render-output format version the tree was produced with (see
      * {@link TEMPLATE_VERSION}). Optional: a manifest written before this field
@@ -836,6 +866,287 @@ declare class ConnectedSourceImmutableError extends Error {
     constructor(table: string, column: string);
 }
 
+/**
+ * Scalar types recognised in `lattice.config.yml` field definitions.
+ *
+ * | YAML type   | SQLite type | TypeScript type |
+ * | ----------- | ----------- | --------------- |
+ * | `uuid`      | TEXT        | string          |
+ * | `text`      | TEXT        | string          |
+ * | `integer`   | INTEGER     | number          |
+ * | `int`       | INTEGER     | number          |
+ * | `real`      | REAL        | number          |
+ * | `float`     | REAL        | number          |
+ * | `boolean`   | INTEGER     | boolean         |
+ * | `bool`      | INTEGER     | boolean         |
+ * | `datetime`  | TEXT        | string          |
+ * | `date`      | TEXT        | string          |
+ * | `blob`      | BLOB        | Buffer          |
+ */
+type LatticeFieldType = 'uuid' | 'text' | 'integer' | 'int' | 'real' | 'float' | 'boolean' | 'bool' | 'datetime' | 'date' | 'blob';
+/**
+ * A single field (column) definition in a `lattice.config.yml` entity.
+ *
+ * @example
+ * ```yaml
+ * id:          { type: uuid,    primaryKey: true }
+ * title:       { type: text,    required: true }
+ * status:      { type: text,    default: open }
+ * assignee_id: { type: uuid }
+ * score:       { type: integer, default: 0 }
+ * ```
+ */
+interface LatticeFieldDef {
+    /** Column data type */
+    type: LatticeFieldType;
+    /** Mark this column as the table's primary key */
+    primaryKey?: boolean;
+    /** Column is NOT NULL */
+    required?: boolean;
+    /** SQL DEFAULT value */
+    default?: string | number | boolean;
+    /**
+     * Per-column audience (Stage-0 scaffolding for the per-viewer enrichment
+     * model). Names who may see this column's value in a cloud. Omitted ⇒
+     * `row-audience` — the value is visible to exactly whoever can see the row,
+     * which is today's behavior, so leaving it unset changes nothing. Later
+     * stages parse a richer grammar (e.g. `subject+role:hr`) and generate a
+     * cell-masking view from it; Stage-0 only records the metadata.
+     */
+    audience?: string;
+    /**
+     * DEPRECATED (3.x) per-field foreign-key shorthand: `ref: <targetTable>` declared
+     * a `belongsTo` whose relation name is the field name with a trailing `_id`
+     * stripped. Superseded by the explicit entity-level `relations:` block. 4.0 still
+     * PARSES it (converted to a `belongsTo` in-memory) so existing 3.0+ configs keep
+     * working, and the GUI silently rewrites it to `relations:` on open so configs
+     * migrate forward. A future major may drop this once configs have upgraded.
+     */
+    ref?: string;
+    /**
+     * Marks this field as a COMPUTED column: a real, materialized column on the base
+     * table whose value is derived (not hand-entered) using one of the computed field
+     * kinds (alias / calc / ai_classify / ai_transform / aggregate — the same vocabulary
+     * the retired computed-TABLE views used). Because it is a real column it is
+     * queryable/filterable/sortable and appears in `SELECT *`. A field is computed iff it
+     * carries `computed:`; deterministic kinds recompute synchronously on write, AI kinds
+     * fill asynchronously. See src/schema/computed-field.ts.
+     */
+    computed?: ComputedFieldDef;
+}
+/**
+ * Inline render spec inside YAML — a flat object alternative to `TemplateRenderSpec`.
+ *
+ * @example
+ * ```yaml
+ * render:
+ *   template: default-list
+ *   formatRow: "{{title}} — {{status}}"
+ * ```
+ */
+interface LatticeEntityRenderSpec {
+    template: string;
+    formatRow?: string;
+}
+/**
+ * A single entity (table) definition in `lattice.config.yml`.
+ *
+ * @example
+ * ```yaml
+ * ticket:
+ *   fields:
+ *     id:          { type: uuid, primaryKey: true }
+ *     title:       { type: text, required: true }
+ *     assignee_id: { type: uuid }
+ *   relations:
+ *     assignee:
+ *       type: belongsTo
+ *       table: user
+ *       foreignKey: assignee_id
+ *   render: default-list
+ *   outputFile: context/TICKETS.md
+ * ```
+ */
+interface LatticeEntityDef {
+    /** Column definitions */
+    fields: Record<string, LatticeFieldDef>;
+    /**
+     * Explicit `belongsTo` relations for this entity, keyed by relation name.
+     *
+     * Each entry declares a foreign key on THIS entity pointing at another
+     * table: `{ type: belongsTo, table, foreignKey, references? }`. The
+     * `foreignKey` names a plain field on this entity; `references` is the
+     * column on the related table (defaults to its primary key). The relation
+     * name (the map key) is whatever you choose — it is not derived from the
+     * field name.
+     *
+     * @example
+     * ```yaml
+     * relations:
+     *   assignee:
+     *     type: belongsTo
+     *     table: user
+     *     foreignKey: assignee_id
+     *     # references: id   # optional; defaults to the target's primary key
+     * ```
+     */
+    relations?: Record<string, BelongsToRelation>;
+    /**
+     * How to render rows into context text.
+     * Accepts the same forms as `TableDefinition.render`:
+     * - A `BuiltinTemplateName` string (e.g. `default-list`)
+     * - A `{ template, formatRow }` object for hooks
+     */
+    render?: string | LatticeEntityRenderSpec;
+    /** Render output file path (relative to the config file directory) */
+    outputFile: string;
+    /**
+     * Optional explicit primary key override.
+     * If omitted, the field with `primaryKey: true` is used.
+     * Accepts a single column name or an array for composite keys.
+     */
+    primaryKey?: string | string[];
+}
+/**
+ * A single field of a computed table. Every field has a direct computation:
+ *
+ * - `alias` — project a base column (`'status'`) or a dotted belongsTo path
+ *   (`'assignee.team.name'`, resolved through declared relations).
+ * - `calc` — a sandboxed calculation expression over base columns / belongsTo
+ *   paths (see `schema/calc-expr.ts` for the grammar). `type` is the display
+ *   type; defaults to `text`.
+ * - `ai_classify` — a model-assigned label for the field's `input` value,
+ *   constrained to `labels`. Model outputs are materialized once into the
+ *   `__lattice_ai_map` bookkeeping table and LEFT JOINed by the view — the
+ *   model is never re-run at read time.
+ * - `ai_transform` — a model-derived free-form value over `inputs` (order is
+ *   part of the cache identity). Materialized into `__lattice_ai_cell` per
+ *   row and LEFT JOINed; a changed source row makes the join miss, so the
+ *   field reads NULL until the next fill pass — never a stale value.
+ * - `aggregate` — fold many junction rows into one scalar per base row via a
+ *   correlated subquery. `via` is `'<junctionTable>.<remoteRelationOrTable>'`
+ *   (e.g. `'ticket_tags.tag'`); `column` names the remote column to aggregate
+ *   (required for every `fn` except `count`).
+ */
+type ComputedFieldDef = {
+    kind: 'alias';
+    source: string;
+} | {
+    kind: 'calc';
+    expr: string;
+    type?: LatticeFieldType;
+} | {
+    kind: 'ai_classify';
+    input: string;
+    prompt: string;
+    labels: string[];
+    model?: 'default' | 'cheapest';
+} | {
+    kind: 'ai_transform';
+    inputs: string[];
+    prompt: string;
+    model?: 'default' | 'cheapest';
+} | {
+    kind: 'aggregate';
+    via: string;
+    fn: 'count' | 'sum' | 'avg' | 'min' | 'max' | 'concat';
+    column?: string;
+};
+/**
+ * A computed table: a live, read-only SQL VIEW defined over one base table
+ * (a declared entity or another computed table). The view always projects the
+ * base primary key as `id` first, then each field in declaration order.
+ * Registered at init as a queryable, non-writable table.
+ *
+ * @example
+ * ```yaml
+ * computed:
+ *   ticket_summary:
+ *     base: ticket
+ *     fields:
+ *       title:     { kind: alias, source: title }
+ *       team:      { kind: alias, source: assignee.team.name }
+ *       is_urgent: { kind: calc, expr: "priority >= 3", type: boolean }
+ *       tag_count: { kind: aggregate, via: ticket_tags.tag, fn: count }
+ * ```
+ */
+interface ComputedTableDef {
+    /** Base table: a declared entity or another computed table. */
+    base: string;
+    /** Optional human description (display metadata only). */
+    description?: string;
+    /** Field definitions, projected in declaration order. */
+    fields: Record<string, ComputedFieldDef>;
+}
+/**
+ * The top-level `lattice.config.yml` document.
+ *
+ * @example
+ * ```yaml
+ * db: ./data/app.db
+ * entities:
+ *   ticket:
+ *     fields:
+ *       id: { type: uuid, primaryKey: true }
+ *       title: { type: text, required: true }
+ *     render: default-list
+ *     outputFile: context/TICKETS.md
+ * ```
+ */
+interface LatticeConfig {
+    /** Path to the SQLite database file (relative to the config file) */
+    db: string;
+    /** Entity (table) definitions */
+    entities: Record<string, LatticeEntityDef>;
+    /** Entity context directory definitions */
+    entityContexts?: Record<string, LatticeEntityContextDef>;
+    /** Computed-table (read-only SQL projection) definitions */
+    computed?: Record<string, ComputedTableDef>;
+}
+/**
+ * Source spec in YAML config — either the shorthand string 'self' or an object.
+ */
+type LatticeEntityContextSourceDef = 'self' | {
+    type: 'hasMany';
+    table: string;
+    foreignKey: string;
+    references?: string;
+} | {
+    type: 'manyToMany';
+    junctionTable: string;
+    localKey: string;
+    remoteKey: string;
+    remoteTable: string;
+    references?: string;
+} | {
+    type: 'belongsTo';
+    table: string;
+    foreignKey: string;
+    references?: string;
+};
+/** A single per-entity file spec in YAML config */
+interface LatticeEntityContextFileDef {
+    source: LatticeEntityContextSourceDef;
+    template: string;
+    budget?: number;
+    omitIfEmpty?: boolean;
+}
+/** Entity context definition in YAML config */
+interface LatticeEntityContextDef {
+    slug: string;
+    directoryRoot?: string;
+    protectedFiles?: string[];
+    index?: {
+        outputFile: string;
+        render: string;
+    };
+    files: Record<string, LatticeEntityContextFileDef>;
+    combined?: {
+        outputFile: string;
+        exclude?: string[];
+    };
+}
+
 /**
  * Declarative computed columns + materialized rollups.
  *
@@ -1484,6 +1795,15 @@ interface TableDefinition {
      * `refreshMaterializedRollups`. See {@link MaterializedRollupSpec}.
      */
     materializedRollups?: Record<string, MaterializedRollupSpec>;
+    /**
+     * Serializable computed COLUMNS (5.0+) — a real, materialized column derived by a
+     * computed field kind (alias / calc / ai_classify / ai_transform / aggregate; the
+     * same vocabulary the retired computed-TABLE views used). Because it is a real
+     * column it is queryable / filterable / sortable and appears in `SELECT *`.
+     * Deterministic kinds recompute on write (bounded, dep-gated); AI kinds fill
+     * asynchronously. Compiled + wired by {@link file://./schema/computed-field.ts}.
+     */
+    computedFields?: Record<string, ComputedFieldDef>;
     /**
      * Mark this table as a *connected data type* (4.3+) — its rows are ingested
      * from an external system through a connector rather than authored locally.
@@ -1512,6 +1832,25 @@ interface FtsConfig {
     /** Columns to index. Omit to auto-detect the table's text columns. */
     fields?: string[];
 }
+/**
+ * Native ANN index build tuning (pgvector HNSW). Defaults match pgvector's own,
+ * so omitting this builds exactly as before. Has no effect on the in-process scan
+ * or on sqlite-vec.
+ */
+interface VectorIndexOptions {
+    /** HNSW graph degree `m` (pgvector default 16). Higher → better recall, more memory + slower build. */
+    m?: number;
+    /** HNSW build candidate-list size `ef_construction` (pgvector default 64). Higher → better recall, slower build. */
+    efConstruction?: number;
+    /**
+     * Index storage precision. `'halfvec'` (pgvector ≥ 0.7) stores the derived index
+     * at 16-bit half precision — roughly halving its memory at a small recall cost —
+     * while the embeddings store stays full precision, so the scan fallback remains
+     * exact. Default `'none'` (full-precision `vector`). pgvector only; ignored on
+     * sqlite-vec.
+     */
+    quantization?: 'none' | 'halfvec';
+}
 /**
  * Configuration for embedding-based semantic search on a table.
  */
@@ -1554,6 +1893,12 @@ interface EmbeddingsConfig {
      * so it fails loudly and tells you to add a pgvector index or raise the cap.
      */
     maxScanChunks?: number;
+    /**
+     * Optional native-index build tuning (pgvector HNSW `m` / `ef_construction`),
+     * applied by `buildVectorIndex`. Omit for pgvector's defaults. No effect on the
+     * in-process scan or sqlite-vec. Backward compatible — omitting it builds as before.
+     */
+    index?: VectorIndexOptions;
 }
 /**
  * Options for `Lattice.search()`.
@@ -1580,6 +1925,12 @@ interface SearchOptions {
      * to `topK`. Defaults to `max(topK * 4, 20)`. Ignored when no reranker is set.
      */
     rerankPoolSize?: number;
+    /**
+     * Query-time HNSW search breadth (pgvector `hnsw.ef_search`) for the indexed
+     * vector arm. Higher trades latency for recall. Omit for pgvector's default. No
+     * effect without a native index (the in-process scan is already exact).
+     */
+    efSearch?: number;
 }
 /**
  * A single search result returned by `Lattice.search()`.
@@ -1781,6 +2132,14 @@ interface CountOptions {
     /** Advanced filter clauses (same as QueryOptions.filters) */
     filters?: FilterExpr[];
 }
+interface BoundedCountOptions extends CountOptions {
+    /**
+     * Stop counting after this many matching rows (default 1000). The query scans at
+     * most `cap + 1` rows, so it never becomes an O(table) COUNT on a huge table;
+     * callers render a result greater than `cap` as an approximate "cap+".
+     */
+    cap?: number;
+}
 /** SQL aggregate function. */
 type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
 /** One aggregate column in an {@link AggregateOptions}. */
@@ -1914,6 +2273,9 @@ interface SeedResult {
     upserted: number;
     linked: number;
     softDeleted: number;
+    /** Records skipped because they had no natural-key value to identity-match on (so they
+     *  couldn't be upserted). 0 when every record had a key. Surfaced, never silently dropped. */
+    skipped: number;
     /**
      * Links whose target row did not resolve. Empty when every link
      * resolved. Always present, so callers can check
@@ -2623,7 +2985,7 @@ declare class EmbeddingScanTooLargeError extends Error {
  * chunk vectors. Either way results respect `deleted_at IS NULL` on the base
  * table and are de-duplicated to the best-scoring chunk per row.
  */
-declare function searchByEmbedding(adapter: StorageAdapter, table: string, queryText: string, config: EmbeddingsConfig, topK: number, minScore: number, pkColumn?: string): Promise<SearchResult[]>;
+declare function searchByEmbedding(adapter: StorageAdapter, table: string, queryText: string, config: EmbeddingsConfig, topK: number, minScore: number, pkColumn?: string, isCloudMember?: boolean, efSearch?: number): Promise<SearchResult[]>;
 interface RefreshEmbeddingsOptions {
     /** Only re-embed rows whose stored model differs from `config.modelId`. */
     staleModelOnly?: boolean;
@@ -2747,6 +3109,14 @@ interface HybridSearchOptions {
     ranking?: RankingOptions;
     /** Optional reranker over the fused top candidates (graceful fallback). */
     reranker?: RerankerFn;
+    /**
+     * Caller is a scoped cloud member (no grant on the internal embeddings store /
+     * vector index). Routes the vector arm and row materialization through the
+     * member-safe, row-visibility-filtered paths. Default false (owner / local).
+     */
+    isCloudMember?: boolean;
+    /** Query-time HNSW search breadth (pgvector `hnsw.ef_search`) for the vector arm. */
+    efSearch?: number;
 }
 /** Per-result score breakdown (the `--explain` payload). */
 interface HybridScoreBreakdown {
@@ -2910,18 +3280,569 @@ declare function graphAdjacencyBoost<T extends {
 }>(adapter: StorageAdapter, results: T[], opts: GraphBoostOptions): Promise<GraphBoostResult<T>[]>;
 
 /**
- * Seamless cloud file-byte access — an in-database presigned-URL broker.
- *
- * After joining a cloud via invite, a scoped member connects directly to the
- * cloud's Postgres as their own least-privilege role. They can SELECT a `files`
- * row they're allowed to see, but they hold no S3 credential, so fetching the
- * bytes would otherwise fail. This installs a `SECURITY DEFINER` function that,
- * **inside Postgres** (the only place the owner's key lives, away from members),
- * gates on the member's row-visibility and computes a short-lived AWS SigV4
- * presigned URL for exactly that object — so the member fetches/uploads bytes
- * with zero config and never holds a key.
- *
- * Why sign in plpgsql: the secret must never leave the database for a member's
+ * Sandboxed calculation-expression language for computed-table `calc` fields.
+ *
+ * A tokenizer + recursive-descent parser produce a typed AST; SQL is emitted
+ * by re-serializing that AST. Raw user text NEVER reaches the SQL string —
+ * this module is the injection boundary for computed tables. Anything outside
+ * the grammar (semicolons, comment sequences, subqueries, table names, bind
+ * parameters, double quotes, unknown functions) has no token or production,
+ * so it fails with a parse error instead of ever appearing in SQL.
+ *
+ * Supported grammar (precedence, loosest → tightest):
+ *
+ *   OR
+ *   AND
+ *   NOT <expr>
+ *   comparison: `= != <> < <= > >=`, `IS [NOT] NULL`, `[NOT] LIKE`,
+ *               `[NOT] IN (<literal list>)`, `[NOT] BETWEEN a AND b`
+ *   `||` (string concatenation)
+ *   `+ -`
+ *   `* / %`
+ *   unary `-`
+ *   primary: literals, column refs, allowlisted functions, CAST, CASE, `( )`
+ *
+ * Literals: numeric (`12`, `3.5`), `'string'` (with `''` as the only escape,
+ * re-escaped on emit), `NULL`, `TRUE`/`FALSE`. Column refs are a bare
+ * identifier or a dotted belongsTo path, validated at parse time by a
+ * caller-supplied resolver; at emit time the compiler maps each path to a
+ * `"alias"."column"` pair, so identifiers in the output are always
+ * compiler-produced. Emitted expressions are fully parenthesized, so the
+ * grammar's precedence is explicit in the SQL and identical on both dialects.
+ *
+ * Pure module: no I/O, no imports beyond types.
+ */
+type CalcDialect = 'sqlite' | 'postgres';
+/** Target types accepted by `CAST(expr AS <type>)`. */
+type CalcCastType = 'TEXT' | 'INTEGER' | 'REAL';
+/** Binary operators preserved in the AST (comparison `!=` normalizes to `<>`). */
+type BinaryOp = '+' | '-' | '*' | '/' | '%' | '||' | '=' | '<>' | '<' | '<=' | '>' | '>=';
+/** Typed AST. Only these shapes exist — SQL is produced exclusively from them. */
+type CalcNode = {
+    t: 'num';
+    lexeme: string;
+} | {
+    t: 'str';
+    value: string;
+} | {
+    t: 'null';
+} | {
+    t: 'bool';
+    value: boolean;
+} | {
+    t: 'col';
+    path: readonly string[];
+} | {
+    t: 'bin';
+    op: BinaryOp;
+    left: CalcNode;
+    right: CalcNode;
+} | {
+    t: 'logic';
+    op: 'AND' | 'OR';
+    left: CalcNode;
+    right: CalcNode;
+} | {
+    t: 'not';
+    expr: CalcNode;
+} | {
+    t: 'neg';
+    expr: CalcNode;
+} | {
+    t: 'isnull';
+    expr: CalcNode;
+    negated: boolean;
+} | {
+    t: 'like';
+    expr: CalcNode;
+    pattern: CalcNode;
+    negated: boolean;
+} | {
+    t: 'in';
+    expr: CalcNode;
+    items: readonly CalcNode[];
+    negated: boolean;
+} | {
+    t: 'between';
+    expr: CalcNode;
+    low: CalcNode;
+    high: CalcNode;
+    negated: boolean;
+} | {
+    t: 'case';
+    whens: readonly {
+        when: CalcNode;
+        then: CalcNode;
+    }[];
+    elseExpr: CalcNode | null;
+} | {
+    t: 'fn';
+    name: string;
+    args: readonly CalcNode[];
+} | {
+    t: 'cast';
+    expr: CalcNode;
+    to: CalcCastType;
+};
+/** A parsed expression plus the unique column paths it references. */
+interface CalcExpr {
+    readonly ast: CalcNode;
+    /** Unique referenced column paths, in first-appearance order. */
+    readonly columnPaths: readonly (readonly string[])[];
+}
+/**
+ * Column-reference resolver supplied by the caller. Receives the dotted path
+ * split into segments; returns true when the path resolves (a base column, or
+ * a belongsTo chain ending in a column). An unresolved path is a parse error.
+ */
+type CalcRefResolver = (path: readonly string[]) => boolean;
+/** Thrown for any lexical or syntactic violation of the expression grammar. */
+declare class CalcExprError extends Error {
+    readonly position: number;
+    constructor(message: string, position: number);
+}
+/**
+ * Parse a calculation expression, validating every column reference against
+ * `resolveRef`. Throws {@link CalcExprError} on any grammar violation or
+ * unresolved reference.
+ */
+declare function parseCalcExpr(source: string, resolveRef: CalcRefResolver): CalcExpr;
+/** Emit-time context: the dialect and the compiler's path → SQL mapping. */
+interface CalcEmitContext {
+    dialect: CalcDialect;
+    /** Map a resolved column path to its compiled `"alias"."column"` SQL. */
+    columnSql: (path: readonly string[]) => string;
+}
+/**
+ * Serialize a parsed expression to SQL. Every composite node is
+ * parenthesized, so the emitted precedence is explicit and dialect-neutral.
+ */
+declare function emitCalcExpr(expr: CalcExpr, ctx: CalcEmitContext): string;
+
+/**
+ * Compiler for serializable COMPUTED COLUMNS (#10) — the per-entity replacement for the
+ * read-only computed-TABLE views. A computed field (`LatticeFieldDef.computed`) is a real,
+ * materialized column whose value is derived by one of five kinds
+ * (alias / calc / ai_classify / ai_transform / aggregate). This module compiles a
+ * DETERMINISTIC field (alias / calc) into a bounded SQL scalar expression the runtime
+ * recomputes on write via a single targeted `UPDATE … WHERE pk = ?` (one row).
+ *
+ * The SQL is emitted through the SAME `emitCalcExpr` the retired view compiler used, so
+ * there is one source of truth for calc semantics (no JS/SQL divergence). Non-deterministic
+ * or non-same-row kinds are returned as DEFERRED — the field is valid and registered, but
+ * its value is produced by a later mechanism (the AI fill engine for ai_* kinds; the
+ * aggregate/belongsTo-path recompute) rather than the synchronous write-path UPDATE.
+ */
+
+/** Why a computed field is not recomputed by the synchronous same-row UPDATE path. */
+type DeferredReason = 'ai' | 'aggregate' | 'path';
+/** AI-fill recompute metadata, carried so the runtime never re-parses the def. */
+interface AiFieldPlan {
+    kind: 'classify' | 'transform';
+    /** Same-row columns fed to the model — a write to any of these invalidates the cell. */
+    inputs: string[];
+    prompt: string;
+    /** Allowed labels (classify only). */
+    labels?: string[];
+    model: 'default' | 'cheapest';
+}
+/** Aggregate recompute metadata, carried so the runtime never re-parses the def. */
+interface AggregateFieldPlan {
+    /** Junction/child table folded into one scalar per base row. */
+    junction: string;
+    /** Remote relation/column segment of `via` (`'<junction>.<remote>'`). */
+    remote: string;
+    fn: 'count' | 'sum' | 'avg' | 'min' | 'max' | 'concat';
+    /** Remote column to aggregate (required for every fn except count). */
+    column?: string;
+}
+interface CompiledComputedField {
+    /** The physical column the value materializes into. */
+    column: string;
+    /** SQL scalar expression over the base row's OWN columns, for the recompute UPDATE.
+     *  Empty when {@link deferred} is set. */
+    sql: string;
+    /** Same-row columns this value depends on (drives dep-gated recompute). Empty for
+     *  aggregate/path; for a deferred `ai` field these ARE populated (the AI cell is
+     *  invalidated when an input column changes). */
+    deps: string[];
+    /** Set when the value is produced by a later mechanism, not the same-row UPDATE. */
+    deferred?: DeferredReason;
+    /** Present iff `deferred === 'ai'` — drives the async fill + staleness. */
+    ai?: AiFieldPlan;
+    /** Present iff `deferred === 'aggregate'` — drives the correlated-subquery recompute. */
+    aggregate?: AggregateFieldPlan;
+}
+
+/**
+ * Computed-table compiler + registration.
+ *
+ * A computed table is a live, READ-ONLY SQL VIEW over one base table,
+ * declared in the workspace config (`computed:`). This module compiles a
+ * {@link ComputedTableDef} into dialect-specific DDL:
+ *
+ * - The view projects the base primary key `AS "id"` first, then each field
+ *   in declaration order.
+ * - Soft-deleted base rows are filtered (`"b"."deleted_at" IS NULL` when the
+ *   base carries that column). Each unique belongsTo path prefix becomes ONE
+ *   LEFT JOIN with a deterministic alias (`j1`, `j2`, … assigned in
+ *   sorted-path order, so recompiles are byte-stable); a joined table's
+ *   `deleted_at IS NULL` lives in the JOIN's ON clause, so an invisible
+ *   parent nulls the field without dropping the base row.
+ * - `aggregate` fields compile to correlated subqueries over the junction.
+ * - AI fields LEFT JOIN the `__lattice_ai_map` / `__lattice_ai_cell`
+ *   bookkeeping tables (see `computed-fill.ts`) — reads never invoke a model.
+ *   A transform's join matches on an `input_key` computed in SQL from the
+ *   declared inputs IN ORDER, so any source change makes the join miss and
+ *   the field reads NULL until the next fill pass (never stale).
+ * - With `cloud.rowVisible`, every relation gains the same
+ *   `lattice_row_visible(...)` predicate the cell-masking views use, so a
+ *   scoped member's reads stay row-filtered.
+ *
+ * Everything interpolated into SQL is either a validated bare identifier
+ * (see `identifier.ts`), an escaped string literal produced here, or the
+ * re-serialized output of the sandboxed expression parser (`calc-expr.ts`).
+ * Raw config text never reaches the SQL string.
+ */
+
+/** What the compiler needs to know about one referencable table. */
+interface ComputedSchemaTable {
+    /** Column names present on the table. */
+    columns: ReadonlySet<string>;
+    /** Declared belongsTo relations, keyed by relation name. */
+    relations: Readonly<Record<string, BelongsToRelation>>;
+    /** Normalized primary-key columns. */
+    primaryKey: readonly string[];
+    /** Whether the table carries the soft-delete `deleted_at` column. */
+    hasDeletedAt: boolean;
+    /** Canonical Lattice field types, when known (display metadata only). */
+    fieldTypes?: Readonly<Record<string, string>>;
+}
+/** table name → shape; built from the parsed config / live schema registry. */
+type ComputedSchema = ReadonlyMap<string, ComputedSchemaTable>;
+/** One compiled AI-derived field, including the SQL its fill pass runs. */
+interface CompiledAiField {
+    /** Cache key: `<table>.<field>`. */
+    key: string;
+    /** Bare field name. */
+    field: string;
+    kind: 'ai_classify' | 'ai_transform';
+    /** Declared input paths, in config order (order is part of the cache identity). */
+    inputs: readonly string[];
+    /** Compiled SQL expression per input, aligned with `inputs`. */
+    inputSql: readonly string[];
+    /** ai_transform only: the SQL `input_key` expression the view joins on. */
+    inputKeySql?: string;
+    /** ai_transform only: `CAST("b"."<pk>" AS TEXT)`. */
+    rowIdSql?: string;
+    /**
+     * SELECT returning this field's unfilled work (no LIMIT — the fill engine
+     * appends one). Classifier: never-seen DISTINCT input values. Transform:
+     * join-miss rows with `row_id`, the SQL-computed `input_key`, and each
+     * input value as `input_<i>` — the fill engine reads the key from the
+     * database so it can never disagree with the view's join expression.
+     */
+    pendingSql: string;
+    prompt: string;
+    labels?: readonly string[];
+    model: 'default' | 'cheapest';
+}
+interface CompiledComputedTable {
+    viewName: string;
+    /** SELECT body (a preview runs it with LIMIT). */
+    selectSql: string;
+    /** `DROP VIEW IF EXISTS` + `CREATE VIEW`, dialect-specific. */
+    createSql: string;
+    /** `['id', ...fieldNames]` in declaration order. */
+    columns: string[];
+    /** Field → canonical Lattice display type (includes the projected `id`). */
+    fieldTypes: Record<string, string>;
+    /** Base + every joined / junction / remote table (bookkeeping tables excluded). */
+    sources: string[];
+    aiFields: CompiledAiField[];
+    /** Stable hash of `createSql` — the idempotence guard for Postgres DDL. */
+    contentHash: string;
+}
+/** Thrown by {@link computedTableOrder} when computed→computed bases form a cycle. */
+declare class ComputedTableCycleError extends Error {
+    readonly cycle: string[];
+    constructor(cycle: string[]);
+}
+/**
+ * Cloud-compile options. On a secured team cloud a Postgres view executes with
+ * its OWNER's rights, so a computed view must (a) row-filter per viewer with
+ * `lattice_row_visible(...)` predicates and (b) read every source column THROUGH
+ * that table's cell-masking view when one exists — otherwise the computed view
+ * exposes the RAW value of a column the owner masked from this member's role, a
+ * column-level cross-tenant leak that the normal `<t>_v` masked read path would
+ * have caught.
+ */
+interface CloudCompileOptions {
+    rowVisible: true;
+    /**
+     * Source tables that carry a cell-masking view (`<t>_v`, generated from
+     * `__lattice_column_policy`; see cloud/audience.ts). A computed field reading a
+     * column of such a table is compiled to read it through `<t>_v`, which encodes
+     * BOTH per-column masking (a masked cell reads NULL for a member) AND row
+     * visibility — so a table read through its masking view needs no separate
+     * `lattice_row_visible` predicate (the view already applies it).
+     */
+    maskedTables?: ReadonlySet<string>;
+}
+/**
+ * Order computed-table definitions so every base compiles before the tables
+ * built on it (dependencies first). Only bases that are themselves computed
+ * tables participate; entity bases are leaves. Throws
+ * {@link ComputedTableCycleError} on a cycle, naming it.
+ */
+declare function computedTableOrder(defs: Record<string, ComputedTableDef>): string[];
+/**
+ * Compile one computed-table definition into dialect-specific view DDL plus
+ * the metadata later slices need (columns, display types, AI fill SQL).
+ * Pure: validates everything it touches and throws a descriptive error on
+ * any unknown table, relation, or column. `schema` must already contain any
+ * computed table used as `base` (compile in {@link computedTableOrder}).
+ */
+declare function compileComputedTable(name: string, def: ComputedTableDef, schema: ComputedSchema, dialect: 'sqlite' | 'postgres', cloud?: CloudCompileOptions): CompiledComputedTable;
+/**
+ * The registration seam the core exposes to this module — kept structural so
+ * `lattice.ts` can pass a closure-backed host without a runtime import cycle.
+ */
+interface ComputedTableHost {
+    adapter: StorageAdapter;
+    /** Apply version-guarded migrations (the Postgres DDL path). */
+    migrate(migrations: Migration[]): Promise<void>;
+    introspectColumns(table: string): Promise<string[]>;
+    /**
+     * Batch-introspect several tables' columns in ONE round-trip (table → ordered
+     * columns). Optional: when absent, registration falls back to a per-table
+     * {@link introspectColumns} loop. Providing it collapses the post-create
+     * introspection of K computed views into a single `information_schema` query,
+     * so a pooled-cloud open never pays K serial round-trips just to read columns.
+     */
+    introspectAllColumns?(tables: string[]): Promise<Map<string, Set<string>>>;
+    /** Register the already-existing view in the live schema registry. Issues NO DDL. */
+    register(table: string, def: TableDefinition, columns: readonly string[]): void;
+}
+interface RegisterComputedTablesOptions {
+    /** Lookup for every referencable table (entities + already-registered tables). */
+    schema: ComputedSchema;
+    dialect: 'sqlite' | 'postgres';
+    /**
+     * Scoped cloud member open: the role cannot DDL, so register purely by
+     * introspection — no view DDL, no bookkeeping-table creation, and a view
+     * this member cannot see is skipped rather than treated as a failure.
+     */
+    introspectOnly?: boolean;
+    /**
+     * Cloud compile: emit per-relation `lattice_row_visible` predicates and read
+     * masked source tables through their cell-masking `<t>_v` view (see
+     * {@link CloudCompileOptions}).
+     */
+    cloud?: CloudCompileOptions;
+    /**
+     * Runtime (ops-layer) registration: execute the view DDL directly (drop +
+     * recreate) on Postgres too, instead of the content-hash migration the open
+     * path uses. A runtime edit can be REVERTED to a prior definition whose
+     * content hash was already applied once — a version-guarded migration would
+     * skip that DDL and silently leave the view on the newer definition.
+     */
+    directDdl?: boolean;
+}
+interface ComputedRegistrationResult {
+    /** Successfully compiled + registered computed tables, in topo order. */
+    registered: string[];
+    /** Introspect-only opens where the view is not (yet) visible to this role. */
+    skipped: string[];
+    /** Per-table failures. A failure never aborts the open or the other tables. */
+    errors: {
+        table: string;
+        error: string;
+    }[];
+    /** Compiled artifacts, for the fill engine / preview / ops layers. */
+    compiled: Map<string, CompiledComputedTable>;
+}
+/**
+ * Compile every computed-table definition in topological order, execute the
+ * view DDL, introspect the result, and register it with the host.
+ *
+ * DDL is planned dependency-aware: when a table's view must be (re)created —
+ * SQLite and the runtime `directDdl` path always recreate; Postgres recreates
+ * when the definition's content-hash migration has not been applied — every
+ * TRANSITIVE dependent (a computed table based on it) is dropped first in
+ * reverse-topological order and force-recreated afterwards in topological
+ * order. Postgres refuses `DROP VIEW` while dependents exist, so without the
+ * plan a changed base failed to re-register AND took its dependents with it
+ * on the next open; and a dependent whose own hash is unchanged must be
+ * recreated DIRECTLY (its migration version is already recorded — a
+ * version-guarded migrate would skip the CREATE and leave the view missing).
+ * (`CREATE OR REPLACE VIEW` is deliberately not used — it fails whenever the
+ * column list changes.)
+ *
+ * A definition that fails to compile (or whose DDL fails) must NOT brick the
+ * open: it is skipped, recorded under field `'*'` in
+ * `__lattice_computed_state`, reported in the returned result, and the
+ * remaining tables continue. This function itself never throws for a
+ * per-table failure.
+ *
+ * After registration, stored AI outputs whose `prompt_hash` no longer matches
+ * the current definition are purged ({@link purgeStaleAiFields}), so a
+ * definition changed through ANY path (ops layer, hand-edited YAML,
+ * member-hydrated config) never keeps serving values derived from a prompt or
+ * label set that no longer exists.
+ */
+declare function registerComputedTables(host: ComputedTableHost, defs: Record<string, ComputedTableDef>, opts: RegisterComputedTablesOptions): Promise<ComputedRegistrationResult>;
+
+/**
+ * AI-fill engine for computed tables.
+ *
+ * AI-derived fields never re-run a model at read time: model outputs are
+ * materialized once into shared bookkeeping tables that the computed-table
+ * view LEFT JOINs, so reads are always deterministic SQL.
+ *
+ * Three unregistered `__lattice_` bookkeeping tables (raw DDL, dialect-neutral,
+ * no SQL-side defaults — every writer supplies explicit ISO timestamps, keeping
+ * the CREATE byte-identical across dialects):
+ *
+ * - `__lattice_ai_map` — classifier memo: one row per (field, distinct input
+ *   value). `label` is NULLABLE: NULL records "the model declined", kept so the
+ *   same value is never re-asked. The view joins on the CAST-to-TEXT input.
+ * - `__lattice_ai_cell` — per-row transform output, keyed (field, row). The
+ *   `input_key` column stores the SQL-computed concatenation of the field's
+ *   inputs; the view's join also matches on it, so a changed source row makes
+ *   the join miss and the field reads NULL until the next fill (never stale).
+ * - `__lattice_computed_state` — per-(table, field) fill status for progress
+ *   and error reporting. Registration failures land here under field `'*'`.
+ *
+ * The LLM is INJECTED via the minimal {@link FillLlm} interface — this module
+ * performs no model calls of its own and the schema layer stays free of any
+ * client dependency. The `model` string passed through is the field's declared
+ * tier (`'default'` / `'cheapest'`); the adapter maps it to a real model id.
+ */
+
+declare const AI_MAP_TABLE = "__lattice_ai_map";
+declare const AI_CELL_TABLE = "__lattice_ai_cell";
+declare const COMPUTED_STATE_TABLE = "__lattice_computed_state";
+/**
+ * Minimal LLM interface the fill engine depends on. Callers adapt their own
+ * client: `model` arrives as the field's declared tier ('default'/'cheapest');
+ * the implementation resolves it to a concrete model. The returned string is
+ * the raw completion text.
+ */
+interface FillLlm {
+    complete(opts: {
+        system: string;
+        user: string;
+        model: string;
+    }): Promise<string>;
+}
+interface ComputedFillOptions {
+    /** Pending items fetched (and classifier values sent) per model call. Default 50. */
+    batchSize?: number;
+}
+/** Per-field outcome of a fill run. */
+interface FieldFillResult {
+    /** Bare field name. */
+    field: string;
+    /** Cache key: `<table>.<field>`. */
+    key: string;
+    kind: 'ai_classify' | 'ai_transform';
+    /** 'idle' when the field converged; 'error' when it stopped early. */
+    status: 'idle' | 'error';
+    /** Rows/values materialized by THIS run. */
+    filled: number;
+    /** Items still unfilled after the run (0 unless the field errored). */
+    pending: number;
+    error?: string;
+}
+/** Report returned by {@link runComputedFill}. Errors are returned, never thrown away. */
+interface ComputedFillReport {
+    table: string;
+    fields: FieldFillResult[];
+}
+/** A row of `__lattice_computed_state`. */
+interface ComputedFieldState {
+    table_name: string;
+    field: string;
+    status: 'idle' | 'running' | 'error';
+    error: string | null;
+    pending: number | null;
+    filled: number | null;
+    started_at: string | null;
+    finished_at: string | null;
+}
+/**
+ * Create the three bookkeeping tables if absent. Idempotent; safe on both
+ * dialects (plain TEXT/INTEGER columns, composite PKs, no defaults).
+ */
+declare function ensureAiTables(adapter: StorageAdapter): Promise<void>;
+/** Read the fill/error state rows for one computed table. */
+declare function readComputedState(adapter: StorageAdapter, tableName: string): Promise<ComputedFieldState[]>;
+/**
+ * Delete every materialized output + state row for one field. Called when the
+ * field's DEFINITION changes (prompt, labels, model, inputs) — the cached
+ * outputs no longer describe the field, so they are purged and the next fill
+ * re-derives them. `fieldKey` is `'<table>.<field>'`.
+ */
+declare function purgeAiField(adapter: StorageAdapter, fieldKey: string): Promise<void>;
+/**
+ * Run the fill pass for every AI field of a compiled computed table.
+ *
+ * - `ai_classify`: only never-seen DISTINCT input values reach the model, in
+ *   batches (~50 per call), as one strict-JSON request mapping each value to a
+ *   label. Every returned label is validated against the allowed set; a value
+ *   with an out-of-set (or missing) label is recorded as an error for the
+ *   field and NEVER stored as a label. A `null` label means the model
+ *   declined — stored so the value is not re-asked.
+ * - `ai_transform`: one model call per join-miss row; the row's `input_key`
+ *   is SELECTed from the database via the same SQL expression the view joins
+ *   on, so the two can never disagree.
+ *
+ * An LLM/parse error records status `'error'` for that field, stops that
+ * field's remaining batches (already-written rows stay), continues the other
+ * fields, and is RETURNED in the report — unfilled rows keep reading NULL via
+ * the view's join miss, never a stale value. This function only throws for
+ * infrastructure failures (e.g. the database itself is unreachable).
+ */
+declare function runComputedFill(adapter: StorageAdapter, llm: FillLlm, compiled: CompiledComputedTable, opts?: ComputedFillOptions): Promise<ComputedFillReport>;
+
+/**
+ * AI fill for #10 computed COLUMNS (the per-entity replacement for the retired
+ * computed-TABLE AI fields). An `ai_classify` / `ai_transform` computed field is a
+ * real column that starts NULL and is populated asynchronously by a model. This
+ * engine scans a bounded window of un-filled cells (`WHERE "<col>" IS NULL`), calls
+ * the injected {@link FillLlm} per row, validates the output, and writes it back with
+ * a single targeted `UPDATE … WHERE pk` (bounded, never a whole-table scan).
+ *
+ * It writes through the raw adapter (NOT `Lattice.update`) so a fill does not re-fire
+ * the write hooks that trigger it — that would loop forever. The staleness contract
+ * ("a changed input NULLs the cell before the refill") is enforced in the write path
+ * (`Lattice._nullStaleAiColumns`); this engine only ever FILLS a NULL cell, so it is
+ * safe to run repeatedly and idempotent once every cell is populated.
+ */
+
+interface FieldFillReport {
+    /** Cells populated this run. */
+    filled: number;
+    /** Cells whose model output was rejected/failed (left NULL). */
+    failed: number;
+    /** First few human-readable failure reasons (never secrets). */
+    errors: string[];
+}
+
+/**
+ * Seamless cloud file-byte access — an in-database presigned-URL broker.
+ *
+ * After joining a cloud via invite, a scoped member connects directly to the
+ * cloud's Postgres as their own least-privilege role. They can SELECT a `files`
+ * row they're allowed to see, but they hold no S3 credential, so fetching the
+ * bytes would otherwise fail. This installs a `SECURITY DEFINER` function that,
+ * **inside Postgres** (the only place the owner's key lives, away from members),
+ * gates on the member's row-visibility and computes a short-lived AWS SigV4
+ * presigned URL for exactly that object — so the member fetches/uploads bytes
+ * with zero config and never holds a key.
+ *
+ * Why sign in plpgsql: the secret must never leave the database for a member's
  * process, so a Node-side presign is out — the signature is computed in-DB via
  * `pgcrypto` HMAC-SHA256. Correctness of the SigV4 chain is verified against
  * AWS's published test vectors (no real S3 needed).
@@ -3303,6 +4224,21 @@ type EventHandler<T> = (data: T) => void;
 type PkLookup = string | Record<string, unknown>;
 declare class Lattice {
     private readonly _adapter;
+    /**
+     * Ambient transaction executor for {@link transaction}. When a store is set,
+     * every write helper routes through it (via {@link _exec}) instead of the base
+     * adapter, so the whole call chain lands on one transaction connection. Scoped
+     * to the async context of the `transaction(fn)` callback, so concurrent callers
+     * never share a transaction.
+     */
+    private readonly _txStore;
+    /**
+     * Serializer for schema mutations (CREATE TABLE / ALTER … ADD COLUMN). See
+     * {@link withSchemaLock}. The flag marks "already inside the lock" for reentrancy;
+     * the chain is the FIFO queue that runs one locked section at a time.
+     */
+    private readonly _schemaLockFlag;
+    private _schemaLockChain;
     private _changelogService?;
     private _changelogWriterInstance?;
     private _reportBuilder?;
@@ -3364,6 +4300,23 @@ declare class Lattice {
     private readonly _computed;
     /** table → materialized rollup specs (P-VIEW). */
     private readonly _rollups;
+    /** table → compiled DETERMINISTIC computed columns (same-row alias/calc, #10) for the
+     *  bounded write-path recompute UPDATE. Deferred kinds (aggregate/AI/belongsTo-path)
+     *  are produced by their own mechanisms and are NOT in this map. */
+    private readonly _computedFieldSql;
+    /** All compiled computed fields per table (incl. deferred) — for introspection + fill. */
+    private readonly _computedFieldPlans;
+    /** table → its AI computed fields (column + input deps + plan) — the async-fill hot path. */
+    private readonly _aiComputedFields;
+    /** Computed-table (read-only view) definitions from the YAML config. */
+    private readonly _configComputedTables;
+    /**
+     * Names of the computed tables registered by this instance — the single
+     * source of truth the write-refusal guard and {@link isComputedTable} share.
+     */
+    private readonly _computedTables;
+    /** Outcome of the init-time computed-table registration (see accessor). */
+    private _computedRegistration;
     /** source table → parents whose rollup it feeds (for incremental recompute). */
     private readonly _rollupSources;
     /**
@@ -3446,6 +4399,88 @@ declare class Lattice {
     init(options?: InitOptions): Promise<void>;
     /** Async tail of init(). See {@link init} for the sync-validation phase. */
     private _initAsync;
+    /**
+     * Register the config-declared computed tables (read-only SQL views) in
+     * topological order: compile, execute the view DDL (SQLite drops +
+     * recreates unconditionally; Postgres guards the DDL behind a content-hash
+     * migration version so a converged open issues none), introspect, and
+     * register each view as a queryable table. A definition that fails to
+     * compile never bricks the open — it is recorded under field `'*'` in
+     * `__lattice_computed_state`, surfaced via {@link getComputedRegistration},
+     * and the remaining tables continue.
+     */
+    private _registerConfigComputedTables;
+    /**
+     * The registration host over THIS instance — shared by the init-time
+     * registration and {@link registerComputedTablesLive} so both register
+     * through the identical seam.
+     */
+    private _computedTableHost;
+    /**
+     * On a secured team cloud, computed views must compile with per-relation
+     * `lattice_row_visible(...)` predicates: a Postgres view executes with its
+     * OWNER's rights, so without the predicates a member granted SELECT on the
+     * view would read every base row, bypassing RLS. The predicate helper only
+     * exists once the cloud RLS bootstrap has run — detected by its
+     * `__lattice_owners` bookkeeping table (same tell `probeCloud` uses). A probe
+     * failure propagates: silently compiling without the predicates on a cloud
+     * would be a row-visibility hole, and a connection broken enough to fail this
+     * one SELECT fails the open anyway.
+     */
+    computedCloudOption(opts?: {
+        introspectOnly?: boolean;
+    }): Promise<CloudCompileOptions | undefined>;
+    /**
+     * Table lookup for the computed-table compiler: every registered table's
+     * declared + introspected columns, belongsTo relations, and normalized
+     * primary key. Shared by the init-time registration and the runtime ops
+     * layer (create/preview/field pickers), so the two can never disagree about
+     * what a definition may reference.
+     */
+    computedSchemaLookup(): Map<string, ComputedSchemaTable>;
+    /**
+     * Register computed-table definitions at RUNTIME — the live counterpart of
+     * the init-time registration, used by the GUI ops layer (create/update). It
+     * runs the SAME registration path as the open (compile in topological order,
+     * bookkeeping-table ensure, view DDL, introspect, live-register) with one
+     * deliberate difference: the view DDL executes directly (drop + recreate)
+     * rather than through the open path's content-hash migration, because a
+     * runtime edit can be reverted to a PRIOR definition whose hash was already
+     * applied once — a version-guarded migration would skip that DDL. Successful
+     * registrations join {@link isComputedTable} / {@link getComputedTableNames}
+     * (so the write-refusal guard covers them immediately) and their compiled
+     * artifacts merge into {@link getComputedRegistration}. Per-definition
+     * failures are RETURNED in `errors`, never thrown — the caller decides
+     * whether a failure aborts its operation.
+     */
+    registerComputedTablesLive(defs: Record<string, ComputedTableDef>): Promise<ComputedRegistrationResult>;
+    /**
+     * Remove a computed table from the live registry — the inverse of
+     * {@link registerComputedTablesLive} for one table. Unregisters the view
+     * from the schema registry (it stops being listed/queryable) and from the
+     * computed-table set (the write-refusal guard no longer names it). Issues NO
+     * DDL — the caller owns dropping the view. Throws for a name that is not a
+     * registered computed table, so a plain entity can never be unregistered
+     * through this path.
+     */
+    unregisterComputedTable(name: string): void;
+    /**
+     * True when `name` is a computed table registered by this instance —
+     * a read-only projection that refuses direct writes.
+     */
+    isComputedTable(name: string): boolean;
+    /** Names of the computed tables registered by this instance. */
+    getComputedTableNames(): string[];
+    /**
+     * Outcome of the init-time computed-table registration: what registered,
+     * what was skipped (introspect-only member opens), per-table errors, and
+     * the compiled artifacts (view SQL + AI fill queries) for downstream
+     * consumers such as the fill engine. Null when the config declares no
+     * computed tables or init has not run.
+     */
+    getComputedRegistration(): ComputedRegistrationResult | null;
+    /** Refuse writes against a computed table — it is a read-only projection. */
+    private _assertNotComputedTable;
     /**
      * Run additional migrations after init(). Useful for package-level schema
      * changes applied at runtime (e.g. update hooks that add columns).
@@ -3469,6 +4504,51 @@ declare class Lattice {
      * Teams schema spec → DDL translation).
      */
     getDialect(): 'sqlite' | 'postgres';
+    /**
+     * The adapter that write/read SQL should execute against: the ambient
+     * transaction connection when inside {@link transaction}, otherwise the base
+     * adapter. Only the row `run`/`get` execution helpers consult this — schema,
+     * introspection, search, and graph helpers keep the base adapter, since those
+     * are structural and should not be scoped to a data transaction.
+     */
+    private _exec;
+    /**
+     * Run `fn` inside a single database transaction. Every write `fn` performs
+     * through this Lattice (insert / update / delete and their audit + changelog
+     * writes) executes on one connection and commits together, or rolls back
+     * together if `fn` throws. Reads inside `fn` see its own uncommitted writes.
+     *
+     * The transaction is scoped to the async context of `fn` (via
+     * `AsyncLocalStorage`), so two concurrent callers on the same Lattice never
+     * accidentally share a transaction. A nested `transaction` call reuses the
+     * outer transaction rather than opening a second one. When the adapter cannot
+     * open a transaction (`withClient` unavailable), `fn` runs WITHOUT one — the
+     * caller's own validation still applies; this mirrors the hard-delete fallback.
+     *
+     * @since 5.0.0
+     */
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Run `fn` with exclusive access to schema mutation. Serializes CREATE TABLE /
+     * ALTER … ADD COLUMN so concurrent callers can't interleave a check-then-DDL
+     * across an `await` and collide. This matters because the SQLite adapter is one
+     * synchronous connection: when a parallel folder ingest has two files that both
+     * extract a new "Invoices" entity, or both add an "amount" column, the un-serialized
+     * loser hits `CREATE TABLE`/`ADD COLUMN` after the winner already ran it and throws
+     * "table already exists" / "duplicate column name". Row INSERTs are deliberately NOT
+     * serialized — they're atomic auto-commit statements with uuid keys and no
+     * read-modify-write, so they stay fully concurrent.
+     *
+     * Reentrant via `AsyncLocalStorage`: a locked section that itself triggers more
+     * DDL (e.g. `createUserEntity` → `addColumn` when securing a cloud table) runs the
+     * nested call inline instead of deadlocking on the queue it already holds — the same
+     * ambient-context pattern as {@link transaction}. A rejected `fn` never poisons the
+     * queue: the chain advances on settle either way, and the caller still sees the
+     * rejection through the returned promise.
+     *
+     * @since 5.0.0
+     */
+    withSchemaLock<T>(fn: () => Promise<T>): Promise<T>;
     /**
      * True when a table opts into the observation/changelog substrate
      * (`def.changelog`). Callers that want to bypass the high-level {@link delete}
@@ -3608,6 +4688,13 @@ declare class Lattice {
     getConnectedSource(table: string): ConnectorSource | undefined;
     /** Names of all registered connected data types (tables with a `source`). */
     connectedTables(): string[];
+    /**
+     * Column names encrypted-at-rest for `table` (decrypted on read). Any caller that ships rows
+     * OUTSIDE the process — an HTTP API response, a render, a log — must mask these; an unmasked
+     * read returns cleartext credentials. Empty set when the table has no encrypted columns or the
+     * encryption layer isn't built yet.
+     */
+    getEncryptedColumns(table: string): ReadonlySet<string>;
     /** Post-insert side effects (changelog, audit, write hooks, embedding sync),
      *  identical for the plain and force-visibility insert paths. */
     private _afterInsert;
@@ -3629,6 +4716,50 @@ declare class Lattice {
      * columns, and fold them into the update payload. No-op otherwise.
      */
     private _recomputeComputedOnUpdate;
+    /**
+     * Recompute the DETERMINISTIC same-row computed columns (#10 alias/calc) for ONE row via
+     * a single bounded `UPDATE … WHERE pk` (one row, no scan). Runs AFTER the row
+     * is written, so the compiler-emitted SQL expressions read the row's own just-written
+     * columns. `changedCols` = the update payload keys (dep-gated recompute); pass `null` for
+     * an insert (recompute every computed column on the new row). The SET right-hand sides
+     * are compiler-generated SQL over validated, quoted column names — never user input.
+     */
+    private _recomputeComputedFieldColumns;
+    /**
+     * Derive computed columns after a row is written: recompute the deterministic same-row
+     * columns and NULL any AI cells whose inputs changed. Called by every write path (insert,
+     * update, upsert, the natural-key upsert/enrich the sync + seed engines use) so a computed
+     * field is never left unpopulated or stale regardless of HOW the row was written.
+     * `changedCols === null` = a full-row write (recompute all + null every AI cell).
+     */
+    private _deriveComputedAfterWrite;
+    /**
+     * NULL the AI computed cells on ONE row whose input columns just changed (one bounded
+     * row update, no scan). The "never serve stale" contract: a changed input clears the derived value
+     * immediately; {@link fillComputedFields} repopulates it out-of-band. `changedCols === null`
+     * NULLs every AI cell on the row (a full-row write, where any input may have changed).
+     */
+    private _nullStaleAiColumns;
+    /**
+     * The compiled computed-field plans for a table (all kinds, incl. deferred AI/aggregate) —
+     * for the GUI field editor + the fill/refresh machinery. Empty when the table has none.
+     */
+    getComputedFieldPlans(table: string): CompiledComputedField[];
+    /** Whether a table has any AI computed fields awaiting fill. */
+    hasAiComputedFields(table: string): boolean;
+    /**
+     * Populate the un-filled (NULL) cells of a table's AI computed fields using the injected
+     * {@link FillLlm}. Kept OUT of the write path (no model calls in the core DB layer) — the GUI
+     * calls this fire-and-forget after a write and on open (backfill), a test injects a fake LLM.
+     * Bounded (scans `WHERE col IS NULL LIMIT n`, skips tombstones). Returns a report;
+     * never throws for a per-cell model failure (those are counted + surfaced in the report).
+     */
+    fillComputedFields(table: string, llm: FillLlm, opts?: {
+        batchSize?: number;
+        maxRows?: number;
+    }): Promise<FieldFillReport>;
+    /** Every table that has AI computed fields (for open-time backfill). */
+    aiComputedFieldTables(): string[];
     /** Recompute parent rollup(s) for the FK values carried on a source row. */
     private _propagateRollupsFromRow;
     /** Recompute the parent rollup(s) fed by a changed source row (fetched by id). */
@@ -3653,6 +4784,21 @@ declare class Lattice {
      * @since 0.17.0
      */
     updateReturning(table: string, id: PkLookup, row: Partial<Row>): Promise<Row>;
+    /**
+     * Permanently delete a row via `DELETE FROM`. This is a **hard delete** —
+     * the row is removed from the table, not soft-deleted via a `deleted_at` column.
+     *
+     * On tables with `changelog: true`, the full previous row is captured and
+     * appended to the changelog before removal, making the delete auditable and
+     * recoverable via {@link rollback}. On tables without a changelog, the row
+     * is gone permanently.
+     *
+     * Side effects:
+     * - If the table has materialized rollups fed by child rows, a deleted child
+     *   is removed from its parent's rollup aggregates.
+     * - Write hooks and audit events are fired.
+     * - Embeddings are synced (if the table has embedding definitions).
+     */
     delete(table: string, id: PkLookup, provenance?: ChangeProvenance): Promise<void>;
     /**
      * Record a DERIVED observation about a row WITHOUT mutating the canonical row.
@@ -3750,6 +4896,21 @@ declare class Lattice {
      *  decrypt deps are wired through `_encryption`, so the query/get decryption
      *  asymmetry is preserved: only query/get invoke them. */
     private get _queryCore();
+    /** Optional host-supplied replacement for the pre-render reverse-sync drain. */
+    private _autoRenderDrainOverride;
+    /**
+     * Route non-error render notices (e.g. an edited generated rollup being
+     * restored) somewhere visible. Default: console.warn. The GUI wires its
+     * activity feed here.
+     */
+    setRenderNoticeHandler(handler: ((message: string) => void) | null): void;
+    /**
+     * Replace the pre-render manual-edit drain (see the auto-render scheduler's
+     * drain dep). The GUI wires its file-loopback watcher here so drained edits go
+     * through the full mutation path (changelog + activity feed + undo) instead of
+     * the core changelog-only apply.
+     */
+    setAutoRenderDrain(drain: ((outputDir: string) => Promise<void>) | null): void;
     /** Lazily-constructed auto-render scheduler (see src/render/auto-render.ts). */
     private get _autoRender();
     /**
@@ -3828,6 +4989,12 @@ declare class Lattice {
      */
     private _expandRelations;
     count(table: string, opts?: CountOptions): Promise<number>;
+    /**
+     * Bounded variant of {@link count}: stops after `opts.cap + 1` matching rows
+     * (default cap 1000) so it stays cheap on large tables. Returns the exact count
+     * when `<= cap`, else `cap + 1` to signal "more than cap" (render as "cap+").
+     */
+    boundedCount(table: string, opts?: BoundedCountOptions): Promise<number>;
     /**
      * SQL-side aggregation — `COUNT`/`SUM`/`AVG`/`MIN`/`MAX` with optional
      * `GROUP BY` and `HAVING`, computed in the database so only the grouped result
@@ -4013,6 +5180,14 @@ declare class Lattice {
      * `reverseSync`. Compares file hashes against the current manifest, so a
      * render-written file is recognized as an echo and skipped.
      */
+    /**
+     * The post-render reconciliation pass: prune files the prior manifest managed
+     * that the new render no longer produces (deleted rows, renamed roots, retired
+     * rollups) — hash-guarded so a manually edited file is never deleted. Runs
+     * automatically after auto/background renders and at workspace open; exposed
+     * for callers that drive `render()` themselves.
+     */
+    reconcileRenderedTree(outputDir: string, prevManifest: LatticeManifest | null, newManifest: LatticeManifest | null): Promise<CleanupResult>;
     reverseSyncFromFiles(outputDir: string, opts?: ReverseSyncProcessOptions): Promise<ReverseSyncResult>;
     watch(outputDir: string, opts?: WatchOptions): Promise<StopFn>;
     on(event: 'audit', handler: EventHandler<AuditEvent>): this;
@@ -4087,6 +5262,17 @@ declare class Lattice {
     private _serializePkLookup;
     /** Returns a rejected Promise if not initialized; null if ready. */
     private _fireWriteHooks;
+    /**
+     * Suspend auto-render (re-entrant) for the duration of a bulk operation — e.g.
+     * ingesting a folder of hundreds of files. Writes still record their render
+     * scope, but no render fires until {@link resumeAutoRender} balances every
+     * pause, at which point ONE coalesced render covers everything. This removes
+     * the O(N²) "render-per-file" blowup where each of N writes re-scanned the
+     * whole (growing) file set. Always pair with resumeAutoRender in a `finally`.
+     */
+    pauseAutoRender(): this;
+    /** Balance a {@link pauseAutoRender}; the last resume arms one coalesced render. */
+    resumeAutoRender(): this;
     /**
      * Turn on automatic rendering into `outputDir`. After this, every insert /
      * update / delete debounce-triggers a re-render (coalesced, so a bulk seed
@@ -4152,242 +5338,44 @@ declare class Lattice {
     recentChanges(opts?: {
         table?: string;
         since?: string;
-        limit?: number;
-    }): Promise<ChangeEntry[]>;
-    /**
-     * Rollback a specific change by applying the inverse operation.
-     * The rollback itself is recorded as a new changelog entry.
-     */
-    rollback(changeId: string): Promise<void>;
-    /**
-     * Show field-level diff between two changelog entries for the same row.
-     */
-    diff(table: string, id: string, fromChangeId: string, toChangeId: string): Promise<Record<string, {
-        old: unknown;
-        new: unknown;
-    }>>;
-    /**
-     * Reconstruct the row state at a specific changelog entry by replaying
-     * all operations up to and including that entry.
-     */
-    snapshot(table: string, id: string, changeId: string): Promise<Record<string, unknown>>;
-    /**
-     * Manually prune changelog entries based on the configured retention policy.
-     * Also callable directly for on-demand cleanup.
-     */
-    pruneChangelog(): Promise<void>;
-    private _notInitError;
-    /**
-     * Returns a rejected Promise if any of the given column names are not present
-     * in the table's schema; null if all columns are valid.
-     *
-     * Applied on the read path (query/count) to validate WHERE and filter column
-     * names before they are interpolated into SQL. The write path strips unknown
-     * columns via _filterToSchemaColumns; the read path rejects instead to avoid
-     * silently discarding intended filter conditions.
-     *
-     * Unregistered tables (accessed via the raw `.db` handle) are passed through.
-     */
-    private _invalidColumnError;
-    private _assertNotInit;
-}
-
-/**
- * Scalar types recognised in `lattice.config.yml` field definitions.
- *
- * | YAML type   | SQLite type | TypeScript type |
- * | ----------- | ----------- | --------------- |
- * | `uuid`      | TEXT        | string          |
- * | `text`      | TEXT        | string          |
- * | `integer`   | INTEGER     | number          |
- * | `int`       | INTEGER     | number          |
- * | `real`      | REAL        | number          |
- * | `float`     | REAL        | number          |
- * | `boolean`   | INTEGER     | boolean         |
- * | `bool`      | INTEGER     | boolean         |
- * | `datetime`  | TEXT        | string          |
- * | `date`      | TEXT        | string          |
- * | `blob`      | BLOB        | Buffer          |
- */
-type LatticeFieldType = 'uuid' | 'text' | 'integer' | 'int' | 'real' | 'float' | 'boolean' | 'bool' | 'datetime' | 'date' | 'blob';
-/**
- * A single field (column) definition in a `lattice.config.yml` entity.
- *
- * @example
- * ```yaml
- * id:          { type: uuid,    primaryKey: true }
- * title:       { type: text,    required: true }
- * status:      { type: text,    default: open }
- * assignee_id: { type: uuid }
- * score:       { type: integer, default: 0 }
- * ```
- */
-interface LatticeFieldDef {
-    /** Column data type */
-    type: LatticeFieldType;
-    /** Mark this column as the table's primary key */
-    primaryKey?: boolean;
-    /** Column is NOT NULL */
-    required?: boolean;
-    /** SQL DEFAULT value */
-    default?: string | number | boolean;
-    /**
-     * Per-column audience (Stage-0 scaffolding for the per-viewer enrichment
-     * model). Names who may see this column's value in a cloud. Omitted ⇒
-     * `row-audience` — the value is visible to exactly whoever can see the row,
-     * which is today's behavior, so leaving it unset changes nothing. Later
-     * stages parse a richer grammar (e.g. `subject+role:hr`) and generate a
-     * cell-masking view from it; Stage-0 only records the metadata.
-     */
-    audience?: string;
-    /**
-     * DEPRECATED (3.x) per-field foreign-key shorthand: `ref: <targetTable>` declared
-     * a `belongsTo` whose relation name is the field name with a trailing `_id`
-     * stripped. Superseded by the explicit entity-level `relations:` block. 4.0 still
-     * PARSES it (converted to a `belongsTo` in-memory) so existing 3.0+ configs keep
-     * working, and the GUI silently rewrites it to `relations:` on open so configs
-     * migrate forward. A future major may drop this once configs have upgraded.
-     */
-    ref?: string;
-}
-/**
- * Inline render spec inside YAML — a flat object alternative to `TemplateRenderSpec`.
- *
- * @example
- * ```yaml
- * render:
- *   template: default-list
- *   formatRow: "{{title}} — {{status}}"
- * ```
- */
-interface LatticeEntityRenderSpec {
-    template: string;
-    formatRow?: string;
-}
-/**
- * A single entity (table) definition in `lattice.config.yml`.
- *
- * @example
- * ```yaml
- * ticket:
- *   fields:
- *     id:          { type: uuid, primaryKey: true }
- *     title:       { type: text, required: true }
- *     assignee_id: { type: uuid }
- *   relations:
- *     assignee:
- *       type: belongsTo
- *       table: user
- *       foreignKey: assignee_id
- *   render: default-list
- *   outputFile: context/TICKETS.md
- * ```
- */
-interface LatticeEntityDef {
-    /** Column definitions */
-    fields: Record<string, LatticeFieldDef>;
-    /**
-     * Explicit `belongsTo` relations for this entity, keyed by relation name.
-     *
-     * Each entry declares a foreign key on THIS entity pointing at another
-     * table: `{ type: belongsTo, table, foreignKey, references? }`. The
-     * `foreignKey` names a plain field on this entity; `references` is the
-     * column on the related table (defaults to its primary key). The relation
-     * name (the map key) is whatever you choose — it is not derived from the
-     * field name.
-     *
-     * @example
-     * ```yaml
-     * relations:
-     *   assignee:
-     *     type: belongsTo
-     *     table: user
-     *     foreignKey: assignee_id
-     *     # references: id   # optional; defaults to the target's primary key
-     * ```
-     */
-    relations?: Record<string, BelongsToRelation>;
-    /**
-     * How to render rows into context text.
-     * Accepts the same forms as `TableDefinition.render`:
-     * - A `BuiltinTemplateName` string (e.g. `default-list`)
-     * - A `{ template, formatRow }` object for hooks
-     */
-    render?: string | LatticeEntityRenderSpec;
-    /** Render output file path (relative to the config file directory) */
-    outputFile: string;
-    /**
-     * Optional explicit primary key override.
-     * If omitted, the field with `primaryKey: true` is used.
-     * Accepts a single column name or an array for composite keys.
-     */
-    primaryKey?: string | string[];
-}
-/**
- * The top-level `lattice.config.yml` document.
- *
- * @example
- * ```yaml
- * db: ./data/app.db
- * entities:
- *   ticket:
- *     fields:
- *       id: { type: uuid, primaryKey: true }
- *       title: { type: text, required: true }
- *     render: default-list
- *     outputFile: context/TICKETS.md
- * ```
- */
-interface LatticeConfig {
-    /** Path to the SQLite database file (relative to the config file) */
-    db: string;
-    /** Entity (table) definitions */
-    entities: Record<string, LatticeEntityDef>;
-    /** Entity context directory definitions */
-    entityContexts?: Record<string, LatticeEntityContextDef>;
-}
-/**
- * Source spec in YAML config — either the shorthand string 'self' or an object.
- */
-type LatticeEntityContextSourceDef = 'self' | {
-    type: 'hasMany';
-    table: string;
-    foreignKey: string;
-    references?: string;
-} | {
-    type: 'manyToMany';
-    junctionTable: string;
-    localKey: string;
-    remoteKey: string;
-    remoteTable: string;
-    references?: string;
-} | {
-    type: 'belongsTo';
-    table: string;
-    foreignKey: string;
-    references?: string;
-};
-/** A single per-entity file spec in YAML config */
-interface LatticeEntityContextFileDef {
-    source: LatticeEntityContextSourceDef;
-    template: string;
-    budget?: number;
-    omitIfEmpty?: boolean;
-}
-/** Entity context definition in YAML config */
-interface LatticeEntityContextDef {
-    slug: string;
-    directoryRoot?: string;
-    protectedFiles?: string[];
-    index?: {
-        outputFile: string;
-        render: string;
-    };
-    files: Record<string, LatticeEntityContextFileDef>;
-    combined?: {
-        outputFile: string;
-        exclude?: string[];
-    };
+        limit?: number;
+    }): Promise<ChangeEntry[]>;
+    /**
+     * Rollback a specific change by applying the inverse operation.
+     * The rollback itself is recorded as a new changelog entry.
+     */
+    rollback(changeId: string): Promise<void>;
+    /**
+     * Show field-level diff between two changelog entries for the same row.
+     */
+    diff(table: string, id: string, fromChangeId: string, toChangeId: string): Promise<Record<string, {
+        old: unknown;
+        new: unknown;
+    }>>;
+    /**
+     * Reconstruct the row state at a specific changelog entry by replaying
+     * all operations up to and including that entry.
+     */
+    snapshot(table: string, id: string, changeId: string): Promise<Record<string, unknown>>;
+    /**
+     * Manually prune changelog entries based on the configured retention policy.
+     * Also callable directly for on-demand cleanup.
+     */
+    pruneChangelog(): Promise<void>;
+    private _notInitError;
+    /**
+     * Returns a rejected Promise if any of the given column names are not present
+     * in the table's schema; null if all columns are valid.
+     *
+     * Applied on the read path (query/count) to validate WHERE and filter column
+     * names before they are interpolated into SQL. The write path strips unknown
+     * columns via _filterToSchemaColumns; the read path rejects instead to avoid
+     * silently discarding intended filter conditions.
+     *
+     * Unregistered tables (accessed via the raw `.db` handle) are passed through.
+     */
+    private _invalidColumnError;
+    private _assertNotInit;
 }
 
 /** Output of a successful config parse — ready to hand to Lattice. */
@@ -4410,6 +5398,11 @@ interface ParsedConfig {
         table: string;
         definition: EntityContextDefinition;
     }[];
+    /** Computed-table (read-only SQL projection) definitions in declaration order */
+    computedTables: readonly {
+        name: string;
+        definition: ComputedTableDef;
+    }[];
 }
 /**
  * Read, parse, and validate a `lattice.config.yml` file.
@@ -4498,9 +5491,9 @@ declare function fixSchemaConflicts(db: Database.Database, checks: {
 }[]): void;
 
 /**
- * Derive a 256-bit AES key from a master password using scrypt.
- * The salt is fixed per Lattice instance — callers should use a unique
- * master key per database.
+ * Derive a 256-bit AES key from a master password using scrypt (memoized by the
+ * master-key value). The salt is fixed per Lattice instance — callers should use a
+ * unique master key per database.
  */
 declare function deriveKey(masterKey: string): Buffer;
 /**
@@ -4569,7 +5562,7 @@ declare function markdownTable(rows: Row[], columns: MarkdownTableColumn[]): str
  * @example `slugify('My Agent Name')  // 'my-agent-name'`
  * @example `slugify('José García')    // 'jose-garcia'`
  */
-declare function slugify(name: string): string;
+declare function slugify$1(name: string): string;
 /**
  * Truncate content at a character budget.
  *
@@ -4892,11 +5885,39 @@ declare class DenoSqliteAdapter implements StorageAdapter {
     private readonly _path;
     private readonly _wal;
     private readonly _busyTimeout;
+    /**
+     * Prepared-statement cache, keyed by SQL text. This is load-bearing, not an
+     * optimization: `node:sqlite`'s `DatabaseSync.prepare()` — unlike `better-sqlite3`,
+     * which caches compiled statements internally — compiles a FRESH native
+     * `sqlite3_stmt` on every call and never finalizes it eagerly. Preparing per call
+     * (as the raw adapter surface does) therefore leaks a native statement every
+     * `run`/`get`/`all`; under a bulk-write loop (e.g. ingesting a folder of files, or
+     * the change-probe watch loop) these accumulate far faster than GC reclaims them and
+     * abort the runtime with a native memory blowup. Caching by SQL text keeps the live
+     * native-statement count flat — the same behavior `better-sqlite3` gives for free.
+     */
+    private readonly _stmtCache;
+    private _stmtCacheMisses;
     constructor(path: string, options?: {
         wal?: boolean;
         busyTimeout?: number;
     });
     get db(): NodeDatabaseSync;
+    /**
+     * Return the compiled statement for `sql`, reusing a cached one when present. A
+     * `node:sqlite` statement is reusable across executions (each `run`/`get`/`all`
+     * re-binds its params), and SQLite's `prepare_v2` auto-recompiles a cached statement
+     * across a schema change (ALTER TABLE) transparently — so reuse is safe. Bounded so a
+     * caller that inlines values into SQL (unbounded distinct text) can't grow it without
+     * limit; on overflow the whole cache is dropped (evicted statements finalize on GC)
+     * and rebuilt from the next calls.
+     */
+    private _prepared;
+    /** Diagnostics: live cached-statement count + total compiles (cache misses). */
+    stmtCacheStats(): {
+        size: number;
+        misses: number;
+    };
     open(): void;
     close(): void;
     run(sql: string, params?: unknown[]): void;
@@ -5207,8 +6228,23 @@ interface Connector {
      * MUST page rather than load everything at once (bounded reads).
      */
     listChanges(toolkit: string, model: string, ctx: ListChangesContext): AsyncIterable<ExternalRecord>;
-    /** Revoke a connected account (teardown). */
+    /**
+     * Optional batch lifecycle. The sync engine calls `beginSyncSession` before a
+     * connector's models are synced and `endSyncSession` after (even on error), so a
+     * connector can open ONE shared resource (e.g. a single MCP transport) and reuse
+     * it across every `listChanges` call instead of reconnecting per parent key.
+     * Connectors that omit these fall back to per-call open (behavior unchanged).
+     */
+    beginSyncSession?(connectionId: string): Promise<void>;
+    endSyncSession?(connectionId: string): Promise<void>;
+    /** Revoke a connected account (teardown). May retain non-secret reconnect state. */
     disconnect(connectionId: string): Promise<void>;
+    /**
+     * Remove ALL local state for a connection, including anything `disconnect`
+     * retained for reconnect (e.g. a stored server URL). Called on hard teardown,
+     * after the registry row is deleted. Optional; omit when disconnect is total.
+     */
+    purgeConnection?(connectionId: string): Promise<void>;
 }
 /**
  * A connector that connects via direct credentials the member pastes in — an API
@@ -5239,14 +6275,109 @@ interface CredentialConnector extends Connector {
  * layer uses this to decide whether to serve the credential connect form.
  */
 declare function isCredentialConnector(c: Connector): c is CredentialConnector;
+/**
+ * How Lattice reaches one MCP server's tools. Everything runs on the local
+ * machine — Lattice IS the MCP client. A remote server is reached over Streamable
+ * HTTP (authorized with that server's own OAuth); a local server runs as a stdio
+ * child process (fully offline, no OAuth). No data is routed through any cloud
+ * middleman (no Lattice-cloud, no model inference).
+ */
+interface McpServerSpec {
+    /** Stable server name (e.g. `'atlassian'`, `'monday'`). */
+    name: string;
+    /** Remote Streamable-HTTP endpoint. Omit for a stdio server. */
+    url?: string;
+    /** Local stdio command (the server runs as a child process, fully offline). */
+    command?: string;
+    /** Args for the stdio command. */
+    args?: string[];
+    /**
+     * Transport. Inferred when omitted: `command` → `'stdio'`, a `url` ending in
+     * `/sse` → `'sse'` (the legacy Server-Sent-Events transport many hosted MCP
+     * servers still use), otherwise `'http'` (Streamable HTTP).
+     */
+    transport?: 'http' | 'sse' | 'stdio';
+    /** Whether the server requires OAuth. Defaults to true for HTTP/SSE, false for stdio. */
+    oauth?: boolean;
+}
+/** Begin-connect result: either an OAuth redirect to complete, or an immediate connection. */
+type McpBeginResult = {
+    kind: 'redirect';
+    redirectUrl: string;
+    pendingId: string;
+} | {
+    kind: 'connected';
+    connectionId: string;
+    displayName: string | null;
+};
+/**
+ * A connector whose data comes from an MCP server it reads over a local transport
+ * (mechanism 2 — Lattice is the MCP client, per-server OAuth, tokens in the
+ * machine-local encrypted store). Connecting means authorizing that server, not a
+ * broker or a Claude subscription. The sync engine is unchanged — `listChanges`
+ * calls MCP read tools instead of a bespoke REST client.
+ */
+interface McpConnector extends Connector {
+    /** The MCP server(s) this toolkit reads from. */
+    mcpServers(toolkit: string): McpServerSpec[];
+    /**
+     * Begin connecting. For an OAuth server, run discovery + stash PKCE state and
+     * return a redirect the GUI opens (system browser on desktop). For a local/open
+     * server, validate via `tools/list` and return the connection immediately.
+     * `redirectUri` is where the GUI receives the code; `serverUrl` overrides the
+     * toolkit default (used by the generic bring-your-own-URL connector).
+     * `clientInfo` is a pre-registered OAuth client (id + optional secret) for
+     * authorization servers that support neither a client-ID metadata document nor
+     * dynamic registration. `targetConnectorId` marks a reconnect of an existing
+     * registry row rather than a new connection.
+     */
+    beginConnect(userId: string, toolkit: string, opts?: {
+        redirectUri?: string;
+        serverUrl?: string;
+        clientInfo?: {
+            client_id: string;
+            client_secret?: string;
+        };
+        targetConnectorId?: string;
+    }): Promise<McpBeginResult>;
+    /**
+     * Finish an OAuth connect: exchange the `code`, store the token under
+     * `mcp_creds:<connectionId>`, and return the connection. `serverName` is the
+     * server's self-reported name from the MCP handshake (display-name material);
+     * `targetConnectorId` echoes the reconnect target recorded at begin. Throws
+     * loudly on a mismatched state or a failed exchange — never a silent default.
+     */
+    completeConnect(pendingId: string, params: {
+        code: string;
+        state?: string;
+    }): Promise<{
+        connectionId: string;
+        displayName: string | null;
+        serverName?: string;
+        targetConnectorId?: string;
+    }>;
+    /**
+     * OPTIONAL: discover the server's record shapes and persist a typed schema descriptor for
+     * this connection, so {@link Connector.models} emits one typed table per record kind (namespaced
+     * by `prefix`, the server brand). Present on the introspective generic connector; absent on
+     * fixed-schema connectors. Best-effort — resolves null when the server exposes nothing modelable.
+     */
+    introspect?(connectionId: string, toolkit: string, prefix: string): Promise<unknown>;
+}
+/** True when `c` is an {@link McpConnector} (connects via an MCP server, not credentials). */
+declare function isMcpConnector(c: Connector): c is McpConnector;
 
 /**
  * The connector catalog — the single place every built-in connector is wired.
  *
  * Routes, the sidebar, the settings panel, and sync-all all iterate this list via
- * the data-driven API ({@link Connector.presentation} / `credentialFields` /
- * `models`), so adding a connector is a new module under `src/connectors/<toolkit>/`
- * plus one line here — no route, GUI, or SPI changes.
+ * the data-driven API ({@link Connector.presentation} / `mcpServers` / `models`).
+ *
+ * There is exactly ONE built-in connector: the generic MCP connector. Lattice is
+ * a local MCP client — the user supplies any MCP server URL, authorizes it with
+ * that server's own OAuth, and each added server is its own connection. Nothing
+ * is routed through a cloud middleman, and no provider-specific connector code
+ * exists; a provider is just another MCP server URL.
  *
  * Named `catalog.ts` (not `registry.ts`) to avoid confusion with the
  * `__lattice_connectors` DB table managed in `registry.ts`: this is the in-memory
@@ -5254,8 +6385,8 @@ declare function isCredentialConnector(c: Connector): c is CredentialConnector;
  */
 
 /**
- * Every built-in connector, fresh instances per call. The GUI server passes the
- * result to the connectors routes; toolkit ids must be unique across the list.
+ * The built-in connectors, fresh instances per call. The GUI server passes the
+ * result to the connectors routes.
  */
 declare function builtinConnectors(): Connector[];
 
@@ -5327,7 +6458,7 @@ declare function getConnectorByToolkit(db: Lattice, toolkit: string, connectedBy
  */
 declare function listConnectors(db: Lattice, connectedBy?: string): Promise<ConnectorRecord[]>;
 /** Update a connector's backend connection id + mark it connected (re-auth/reuse). */
-declare function updateConnectorConnection(db: Lattice, id: string, connectionRef: string): Promise<void>;
+declare function updateConnectorConnection(db: Lattice, id: string, connectionRef: string, toolkit?: string): Promise<void>;
 /** Record a sync outcome: success stamps `last_sync_at` + clears the error. */
 declare function recordSync(db: Lattice, id: string, outcome: {
     ok: true;
@@ -5349,296 +6480,577 @@ declare function setConnectorStatus(db: Lattice, id: string, status: ConnectorSt
 declare function deleteConnectorRecord(db: Lattice, id: string): Promise<void>;
 
 /**
- * The Jira connector — a {@link Connector} that talks to Jira Cloud's REST + Agile
- * APIs DIRECTLY via the optional `jira.js` dependency, authenticated with the
- * user's OWN Atlassian credentials (site URL + email + API token, HTTP Basic).
- * No broker, no extra API key.
+ * Shared connector errors.
  *
- * The SPI is OAuth-shaped (authorize→redirect→completeAuth); Jira uses direct
- * credentials instead, so `authorize`/`completeAuth` are not part of its flow —
- * the GUI collects credentials and calls {@link JiraConnector.connect}, which
- * validates them against Jira and stores them encrypted. `listChanges` (sync) and
- * `disconnect` (teardown) satisfy the SPI normally, keyed by the stored
- * connection. The schema (the six connected models) lives in `./models.ts`; this
- * file is the fetch/auth half.
+ * Lives in its own module (not inside any one connector) so every connector and
+ * the GUI routes reference a single {@link ConnectorUnavailableError} identity —
+ * the route layer maps it to a 422 via `instanceof`, so a split identity would
+ * silently break that mapping.
  */
-
-/** The user's Atlassian credentials for one Jira connection. */
-interface JiraCreds {
-    /** Site base URL, e.g. `https://your-domain.atlassian.net`. */
-    site: string;
-    /** Atlassian account email (the Basic-auth username). */
-    email: string;
-    /** Atlassian API token (the Basic-auth password) — a user secret. */
-    apiToken: string;
-}
-/** Thrown when the connector is used but its prerequisites are missing. */
+/** Thrown when a connector is used but its prerequisites are missing. */
 declare class ConnectorUnavailableError extends Error {
     constructor(message: string);
 }
-/** Read the stored credentials for a connection, or null. */
-declare function getJiraCreds(connectionId: string): JiraCreds | null;
-/** Persist credentials for a connection to the machine-local encrypted store. */
-declare function setJiraCreds(connectionId: string, creds: JiraCreds): void;
-/** Remove the stored credentials for a connection. */
-declare function clearJiraCreds(connectionId: string): void;
-type Json$1 = Record<string, unknown>;
-/** The minimal Jira surface the connector depends on (all calls return raw REST shapes). */
-interface JiraClient {
-    /** Validate the credentials + return the authenticated account (`GET /myself`). */
-    myself(): Promise<Json$1>;
-    searchIssues(args: {
-        jql: string;
-        nextPageToken?: string;
-        maxResults: number;
-        fields?: string[];
-    }): Promise<{
-        issues: Json$1[];
-        nextPageToken?: string;
-    }>;
-    searchProjects(args: {
-        startAt: number;
-        maxResults: number;
-    }): Promise<{
-        values: Json$1[];
-        total?: number;
-        isLast?: boolean;
-    }>;
-    getComments(args: {
-        issueIdOrKey: string;
-        startAt: number;
-        maxResults: number;
-    }): Promise<{
-        comments: Json$1[];
-        total?: number;
-    }>;
-    getAllUsers(args: {
-        startAt: number;
-        maxResults: number;
-    }): Promise<Json$1[]>;
-    getAllBoards(args: {
-        startAt: number;
-        maxResults: number;
-    }): Promise<{
-        values: Json$1[];
-        total?: number;
-        isLast?: boolean;
-    }>;
-    getAllSprints(args: {
-        boardId: number;
-        startAt: number;
-        maxResults: number;
-    }): Promise<{
-        values: Json$1[];
-        total?: number;
-        isLast?: boolean;
-    }>;
+
+/**
+ * The MCP transport seam.
+ *
+ * An {@link McpConnector} calls a read tool by name and gets back the tool's raw
+ * JSON result; *how* the call reaches the server is the transport's concern. This
+ * keeps the connector modules (schema + mappers) and the sync engine completely
+ * decoupled from the MCP SDK — and lets tests inject a fake transport with canned
+ * tool JSON instead of standing up a real server.
+ *
+ * There is exactly one production implementation ({@link './direct-transport.ts'}):
+ * Lattice as a local MCP client over Streamable HTTP (remote servers) or stdio
+ * (local server processes). Nothing routes through a cloud middleman.
+ */
+/** One MCP read-tool invocation. */
+interface McpToolCall {
+    /** Tool name (e.g. `'search_threads'`). */
+    tool: string;
+    /** Tool arguments (the tool's input schema). */
+    args: Record<string, unknown>;
+}
+/** A tool discovered on the server (name + optional description), for connect-time validation. */
+interface McpToolInfo {
+    name: string;
+    description?: string;
+}
+/** A resource advertised by the server (`resources/list`) — its "available files". */
+interface McpResourceInfo {
+    name: string;
+    uri: string;
+    description?: string;
+    mimeType?: string;
 }
 /**
- * Build a {@link JiraClient} from `jira.js` (lazy-imported) + the user's creds.
- * Throws {@link ConnectorUnavailableError} if the optional dependency is absent.
- * The dynamic import uses non-literal specifiers so TypeScript does not statically
- * resolve `jira.js` — it need not be installed to compile latticesql.
+ * A live connection to one MCP server. Implementations MUST NOT hold the
+ * connection open across calls unless {@link close} is honored — connectors open
+ * a transport, drain a model's pages, and close.
  */
-declare function loadJiraClient(creds: JiraCreds): Promise<JiraClient>;
-declare class JiraConnector implements CredentialConnector {
-    private readonly clientFactory;
-    private readonly credsLoader;
-    readonly connector = "jira";
-    /**
-     * @param clientFactory builds a {@link JiraClient} from creds (default: the lazy
-     * `jira.js` loader; tests inject a fake).
-     * @param credsLoader resolves a connection id to its stored creds (default: the
-     * machine-local store; tests inject a fake).
-     */
-    constructor(clientFactory?: (creds: JiraCreds) => Promise<JiraClient>, credsLoader?: (connectionId: string) => JiraCreds | null);
-    toolkits(): string[];
-    models(toolkit: string): ConnectedModelDef[];
-    presentation(toolkit: string): ToolkitPresentation;
-    credentialFields(): CredentialField[];
-    helpUrl(): string;
+interface McpTransport {
+    /** List the callable tools on the server (connect-time validation + discovery). */
+    listTools(): Promise<McpToolInfo[]>;
+    /** Call one read tool; returns the parsed JSON content the tool produced. */
+    callTool(call: McpToolCall): Promise<unknown>;
     /**
-     * Jira authenticates with direct credentials, not an OAuth redirect. The GUI
-     * collects the site/email/token and calls {@link connect}; these SPI methods are
-     * therefore not part of the Jira flow and throw a clear, actionable error.
+     * List the server's advertised resources (standard MCP `resources/list`).
+     * Servers without the resources capability yield `[]`, never an error.
      */
-    authorize(_userId: string, _toolkit: string): Promise<AuthorizeResult>;
-    completeAuth(_userId: string, _toolkit: string): Promise<ConnectionResult>;
-    /**
-     * Validate Atlassian credentials against Jira (`GET /myself`) and, on success,
-     * store them encrypted under a fresh connection id. Reads the submitted
-     * `site` / `email` / `token` values (the wire key stays `token`; it maps to the
-     * internal `apiToken`). Returns the connection id (recorded in the registry by
-     * the caller) and the validated account display name (for the UI). Throws a
-     * clear, actionable error if the inputs are missing, the site isn't a URL, or
-     * the credentials are invalid.
-     */
-    connect(creds: Record<string, string>): Promise<{
+    listResources(): Promise<McpResourceInfo[]>;
+    /** The server's self-reported identity from the `initialize` handshake, if known. */
+    serverInfo?(): {
+        name?: string;
+        title?: string;
+        version?: string;
+    } | undefined;
+    /** Close the underlying client/session. */
+    close(): Promise<void>;
+}
+/**
+ * Builds a transport for one connected MCP server. The connector base takes this
+ * as a constructor seam so tests inject a fake and production injects the direct
+ * client. `connectionId` keys the stored OAuth token for the server.
+ */
+type McpTransportFactory = (server: McpServerRef) => Promise<McpTransport>;
+/** The resolved server + connection a transport should attach to. */
+interface McpServerRef {
+    /** Server name (for diagnostics). */
+    name: string;
+    /** Remote endpoint, or undefined for a stdio server. */
+    url?: string;
+    /** Local stdio command + args, or undefined for an HTTP/SSE server. */
+    command?: string;
+    args?: string[];
+    /** `'http'` (Streamable HTTP), `'sse'`, or `'stdio'` — resolved by the connector. */
+    transport: 'http' | 'sse' | 'stdio';
+    /** The registry connection id — keys the stored OAuth token (HTTP/SSE servers). */
+    connectionId: string;
+}
+
+/**
+ * The direct MCP client transport — Lattice talks to an MCP server itself, on the
+ * local machine, over Streamable HTTP (remote servers, per-server OAuth) or stdio
+ * (a local server process, fully offline). This is the only production transport:
+ * no data is routed through a cloud middleman.
+ *
+ * `@modelcontextprotocol/sdk` is an OPTIONAL dependency, lazy-imported with
+ * non-literal specifiers so `latticesql` compiles + installs without it (and so
+ * it resolves under both Node and the desktop Deno runtime). The SDK surface is
+ * hand-typed at the seam, mirroring the Jira `jira.js` seam.
+ */
+
+/**
+ * The transport factory used at SYNC time — the connection is already authorized,
+ * so the stored token is attached and no redirect is expected. Opens a client,
+ * ready for `listChanges` to call read tools.
+ */
+declare function connectDirect(ref: McpServerRef): Promise<McpTransport>;
+interface BeginOAuthArgs {
+    connectionId: string;
+    serverUrl: string;
+    redirectUri: string;
+    state: string;
+    /** `'http'` (Streamable HTTP) or `'sse'`. */
+    transportKind: 'http' | 'sse';
+    clientName?: string;
+    scope?: string;
+}
+interface CompleteOAuthArgs {
+    connectionId: string;
+    redirectUri: string;
+    code: string;
+    /** `'http'` (Streamable HTTP) or `'sse'` — must match the begin call. */
+    transportKind: 'http' | 'sse';
+    clientName?: string;
+    scope?: string;
+    state?: string;
+}
+
+/**
+ * The base for every MCP-backed connector.
+ *
+ * A concrete connector (Gmail, Calendar, Jira, …) supplies only schema + mapping:
+ * the connected {@link ConnectedModelDef}s (`models`), the MCP server(s) it reads
+ * from (`mcpServers`), and, per model, which read tool feeds it and how to map the
+ * tool's JSON into rows (`bindings`). Everything else — connecting (per-server
+ * OAuth or a local stdio server), paging, and yielding {@link ExternalRecord}s to
+ * the unchanged sync engine — lives here.
+ *
+ * The transport and OAuth driver are constructor seams so tests inject fakes and
+ * never touch the network or the MCP SDK.
+ */
+
+/** Binds one connected model to the MCP read tool that feeds it, plus its mapper. */
+interface McpModelBinding {
+    /** The connected model key (matches {@link ConnectedModelDef.model}). */
+    model: string;
+    /** The MCP read tool that feeds this model. */
+    tool: string;
+    /**
+     * Build the tool arguments for one page. `parentKey` is set for per-parent
+     * models (e.g. an issue key when fetching its comments); `cursor` is the page
+     * token from {@link nextCursor} on the prior page (null on the first page).
+     */
+    buildArgs(ctx: {
+        parentKey?: string;
+        cursor?: string | null;
+    }): Record<string, unknown>;
+    /** Pull the array of raw items out of the tool's JSON result. */
+    items(result: unknown): unknown[];
+    /** Map one raw item to an {@link ExternalRecord}. Return null to skip it. */
+    map(item: unknown, ctx: {
+        parentKey?: string;
+    }): ExternalRecord | null;
+    /** Extract the next-page cursor, or a falsy value when the last page was reached. */
+    nextCursor?(result: unknown): string | null | undefined;
+}
+/** OAuth driver seam — the real SDK-backed functions in production, fakes in tests. */
+interface McpOAuthDriver {
+    begin(args: BeginOAuthArgs): Promise<{
+        authorizationUrl: string | undefined;
+        toolNames: string[];
+        serverName?: string;
+    }>;
+    complete(args: CompleteOAuthArgs): Promise<{
+        toolNames: string[];
+        serverName?: string;
+    }>;
+}
+declare abstract class McpConnectorBase implements McpConnector {
+    private readonly transportFactory;
+    private readonly oauth;
+    protected constructor(transportFactory?: McpTransportFactory, oauth?: McpOAuthDriver);
+    abstract readonly connector: string;
+    abstract toolkits(): string[];
+    abstract presentation(toolkit: string): ToolkitPresentation;
+    abstract models(toolkit: string): ConnectedModelDef[];
+    abstract mcpServers(toolkit: string): McpServerSpec[];
+    /** The per-model tool + mapper bindings for a toolkit. */
+    protected abstract bindings(toolkit: string): McpModelBinding[];
+    /** Optional OAuth scope string requested for a toolkit's server. */
+    protected scope(_toolkit: string): string | undefined;
+    private resolveServer;
+    private transportKind;
+    private needsOAuth;
+    private buildRef;
+    /** Open a transport to this toolkit's server for an existing connection (sync time). */
+    protected openServerTransport(toolkit: string, connectionId: string): Promise<McpTransport>;
+    beginConnect(_userId: string, toolkit: string, opts?: {
+        redirectUri?: string;
+        serverUrl?: string;
+        clientInfo?: {
+            client_id: string;
+            client_secret?: string;
+        };
+        targetConnectorId?: string;
+    }): Promise<McpBeginResult>;
+    completeConnect(pendingId: string, params: {
+        code: string;
+        state?: string;
+    }): Promise<{
         connectionId: string;
         displayName: string | null;
+        serverName?: string;
+        targetConnectorId?: string;
     }>;
-    listChanges(toolkit: string, model: string, ctx: ListChangesContext): AsyncIterable<ExternalRecord>;
     disconnect(connectionId: string): Promise<void>;
-    /** Offset-paged fetch (startAt/total/isLast). Stops on isLast, exhausted total, or a short page. */
-    private pageOffset;
-    /** Token-paged fetch (nextPageToken) — the enhanced JQL issue search. */
-    private pageToken;
+    purgeConnection(connectionId: string): Promise<void>;
+    private readonly _activeSessions;
+    private readonly _sessionTransports;
+    /** Reuse ONE transport for this connection across the sync's models/parents. */
+    beginSyncSession(connectionId: string): Promise<void>;
+    /** Close + evict the shared transport opened during the session (idempotent). */
+    endSyncSession(connectionId: string): Promise<void>;
+    listChanges(toolkit: string, model: string, ctx: ListChangesContext): AsyncIterable<ExternalRecord>;
+    authorize(_userId: string, _toolkit: string): Promise<AuthorizeResult>;
+    completeAuth(_userId: string, _toolkit: string): Promise<ConnectionResult>;
+    private displayNameFor;
+}
+/** A single-toolkit MCP connector defined purely by schema + bindings. */
+interface McpConnectorSpec {
+    /** Connector id (also the toolkit id unless {@link toolkit} is set). */
+    connector: string;
+    /** Toolkit id, if it differs from the connector id. */
+    toolkit?: string;
+    presentation: ToolkitPresentation;
+    servers: McpServerSpec[];
+    models: ConnectedModelDef[];
+    bindings: McpModelBinding[];
+    /** OAuth scope requested for the server, if any. */
+    scope?: string;
+}
+/** Test/DI seams for a {@link SimpleMcpConnector}. */
+interface McpConnectorDeps {
+    transportFactory?: McpTransportFactory;
+    oauth?: McpOAuthDriver;
+}
+/**
+ * The concrete connector every built-in MCP connector module instantiates: it
+ * wires a {@link McpConnectorSpec} into the base, so a connector module is just
+ * its table schema + per-model tool bindings — no class boilerplate.
+ */
+declare class SimpleMcpConnector extends McpConnectorBase {
+    private readonly spec;
+    readonly connector: string;
+    private readonly toolkit;
+    constructor(spec: McpConnectorSpec, deps?: McpConnectorDeps);
+    toolkits(): string[];
+    presentation(_toolkit: string): ToolkitPresentation;
+    models(_toolkit: string): ConnectedModelDef[];
+    mcpServers(_toolkit: string): McpServerSpec[];
+    protected bindings(_toolkit: string): McpModelBinding[];
+    protected scope(_toolkit: string): string | undefined;
 }
 
 /**
- * Jira connected data types — the six tables the Jira connector syncs.
- *
- * Pure schema: each model's Lattice {@link TableDefinition} (with a `source`
- * descriptor), its natural key (a stable Jira id/key = the primary key, so
- * re-syncs upsert idempotently), and the FK relations that derive graph edges.
- * The fetch/map logic lives in the connector ({@link JiraConnector}), which calls
- * the Jira REST/Agile API directly via `jira.js` — there is no broker.
+ * Shared builder for MCP-connector connected models — the same "Jira data
+ * conventions" every connector reuses: a Lattice {@link TableDefinition} with the
+ * standard lifecycle columns, a `source` descriptor (per-member `private`
+ * visibility), an `outputFile`, and optional graph edges + a per-parent binding.
  */
 
-/** All six Jira connected models, in dependency order (parents before children). */
-declare const JIRA_MODELS: ConnectedModelDef[];
+interface McpModelArgs {
+    connector: string;
+    toolkit: string;
+    table: string;
+    model: string;
+    naturalKey: string;
+    columns: Record<string, string>;
+    def: Partial<TableDefinition>;
+    graphEdges?: ConnectedModelDef['graphEdges'];
+    parent?: ConnectedModelDef['parent'];
+}
+/** Build a {@link ConnectedModelDef} for an MCP connector (mirrors `jira/models.ts`). */
+declare function mcpModel(args: McpModelArgs): ConnectedModelDef;
+
 /**
- * Define the six Jira connected tables on a live database (post-init), skipping
- * any that already exist. Called before the first sync / on connector setup.
+ * Persisted + memoized schema descriptor for one MCP connection — the MCP analogue of
+ * `db-source/schema-cache.ts`. The connector SPI's `models()` is SYNCHRONOUS, but discovering
+ * an MCP server's record shapes means calling its read tools (async), so introspection happens
+ * in the async connect/refresh path, persists a descriptor in the machine-local encrypted store
+ * (keyed `mcp_schema:<connectionId>`), and `models()` reads it back synchronously via
+ * {@link buildMcpModelDefs}. That turns a server's flat item stream into one TYPED table per
+ * record kind (e.g. `deduction_types`, `company`), each namespaced per connection so two servers
+ * never collide and each auto-groups under its own GUI schema header (via `mcp:<connId>` toolkit).
  */
-declare function defineJiraTables(db: Lattice): Promise<void>;
+
+/** SQL spec inferred for a modeled column. */
+type McpSqlSpec = 'TEXT' | 'INTEGER' | 'REAL';
+interface McpColumnDesc {
+    name: string;
+    sqlSpec: McpSqlSpec;
+}
+/** One record kind discovered on the server → one typed Lattice table. */
+interface McpKindDesc {
+    /** Record kind slug (the table's identity within the connection), e.g. `deduction_types`. */
+    kind: string;
+    /** The server read tool whose items populate this kind (e.g. `list_deduction_types`). */
+    tool: string;
+    /** Modeled columns inferred from sampled items (excludes the natural key + lifecycle cols). */
+    columns: McpColumnDesc[];
+    /** The item field used as the natural key, or `_pk` when synthesized (no stable id field). */
+    naturalKey: string;
+}
+interface McpSchemaDescriptor {
+    /** Sanitized slug namespacing this connection's tables (from the server brand / display name). */
+    prefix: string;
+    kinds: McpKindDesc[];
+}
 
 /**
- * The Trello connector — a {@link Connector} that talks to Trello's REST API
- * DIRECTLY over the Node global `fetch`, authenticated with the user's OWN API
- * key + token (passed as `?key=&token=` query params). No broker, no SDK, no
- * extra dependency.
+ * The introspective MCP connector — the always-works path.
+ *
+ * Point it at ANY reachable MCP server (a URL you supply, or a local stdio
+ * command) and it pulls that server's readable items in as context without a
+ * hand-authored schema: it introspects the server's tools (`tools/list`), calls
+ * each no-argument read tool, and ALSO lists the server's advertised resources
+ * (`resources/list` — its "available files"). Everything lands in one connected
+ * `*_items` table (typed columns for kind/tool/server/title/summary + a JSON
+ * `data` blob, FTS on title/summary, per-member `private` visibility — the same
+ * connector-table conventions the sync engine expects).
  *
- * The SPI is OAuth-shaped (authorize→redirect→completeAuth); Trello uses direct
- * credentials instead, so `authorize`/`completeAuth` are not part of its flow —
- * the GUI collects the API key + token and calls {@link TrelloConnector.connect},
- * which validates them against Trello and stores them encrypted. `listChanges`
- * (sync) and `disconnect` (teardown) satisfy the SPI normally, keyed by the
- * stored connection. The schema (the eleven connected models) lives in
- * `./models.ts`; this file is the fetch/auth half.
+ * Two uses:
+ *  - {@link genericConnector} — the built-in bring-your-own-URL connector; every
+ *    added server is its own connection (one registry row per server).
+ *  - {@link introspectiveConnector} — the same engine pre-pointed at a fixed
+ *    endpoint with its own table name, for library consumers that embed a
+ *    specific provider.
+ *
+ * Only read-shaped tools are called: tools that require arguments are skipped in
+ * introspective mode, and obvious write tools are never called.
  */
 
-/** The user's Trello credentials for one connection. */
-interface TrelloCreds {
-    /** Trello API key (from trello.com/power-ups/admin). */
-    apiKey: string;
-    /** Trello API token authorizing access for this key — a user secret. */
-    token: string;
+/** Configuration for an introspective connector instance. */
+interface IntrospectiveSpec {
+    /** Connector + toolkit id. */
+    connector: string;
+    /** Display label. */
+    label: string;
+    /** Badge letter + colour for the fallback icon. */
+    iconLetter: string;
+    iconColor: string;
+    /** The connected table name (e.g. `'mcp_items'`, `'jira_items'`). */
+    table: string;
+    /** The MCP server(s). A branded connector sets a default url; generic leaves it blank. */
+    servers: McpServerSpec[];
 }
-/** Read the stored credentials for a connection, or null. */
-declare function getTrelloCreds(connectionId: string): TrelloCreds | null;
-/** Persist credentials for a connection to the machine-local encrypted store. */
-declare function setTrelloCreds(connectionId: string, creds: TrelloCreds): void;
-/** Remove the stored credentials for a connection. */
-declare function clearTrelloCreds(connectionId: string): void;
-type Json = Record<string, unknown>;
-/** Options for the paged card/comment fetches (Trello's `before` cursor). */
-interface TrelloPageOpts {
-    /** Max rows to return this page. */
-    limit: number;
-    /** Return only rows older than this id (Trello returns newest-first). */
-    before?: string;
-}
-/** The minimal Trello surface the connector depends on (all calls return raw REST shapes). */
-interface TrelloClient {
-    /** Validate the credentials + return the authenticated member (`GET /members/me`). */
-    me(): Promise<Json>;
-    /** The authenticated member's boards (`GET /members/me/boards`). */
-    myBoards(): Promise<Json[]>;
-    /** A board's lists (`GET /boards/{id}/lists`). */
-    boardLists(boardId: string): Promise<Json[]>;
-    /** A board's members (`GET /boards/{id}/members`). */
-    boardMembers(boardId: string): Promise<Json[]>;
-    /** A board's labels (`GET /boards/{id}/labels`). */
-    boardLabels(boardId: string): Promise<Json[]>;
-    /** A board's cards, paged newest-first via `before` (`GET /boards/{id}/cards`). */
-    boardCards(boardId: string, opts: TrelloPageOpts): Promise<Json[]>;
-    /** A card's `commentCard` actions, paged via `before` (`GET /cards/{id}/actions`). */
-    cardComments(cardId: string, opts: TrelloPageOpts): Promise<Json[]>;
-    /** A card's assigned members (`GET /cards/{id}/members`). */
-    cardMembers(cardId: string): Promise<Json[]>;
-    /** A card's applied labels (`GET /cards/{id}/labels`). */
-    cardLabels(cardId: string): Promise<Json[]>;
-    /** A card's checklists (`GET /cards/{id}/checklists`). */
-    cardChecklists(cardId: string): Promise<Json[]>;
-    /** A checklist's items (`GET /checklists/{id}/checkItems`). */
-    checklistItems(checklistId: string): Promise<Json[]>;
-}
-/**
- * Build a {@link TrelloClient} that talks to Trello over the Node global `fetch`,
- * authenticated with the user's API key + token. No SDK, no extra dependency.
- */
-declare function loadTrelloClient(creds: TrelloCreds): Promise<TrelloClient>;
-declare class TrelloConnector implements CredentialConnector {
-    private readonly clientFactory;
-    private readonly credsLoader;
-    readonly connector = "trello";
+declare class IntrospectiveMcpConnector extends McpConnectorBase {
+    private readonly spec;
+    readonly connector: string;
+    private readonly model;
+    constructor(spec: IntrospectiveSpec, deps?: McpConnectorDeps);
+    toolkits(): string[];
+    presentation(_toolkit: string): ToolkitPresentation;
+    models(toolkit: string): ConnectedModelDef[];
+    mcpServers(_toolkit: string): McpServerSpec[];
+    protected bindings(_toolkit: string): McpModelBinding[];
     /**
-     * @param clientFactory builds a {@link TrelloClient} from creds (default: the
-     * real `fetch`-backed client; tests inject a fake).
-     * @param credsLoader resolves a connection id to its stored creds (default: the
-     * machine-local store; tests inject a fake).
+     * Discover the server's record shapes and persist a typed schema descriptor: call each
+     * non-write read tool once, infer a kind + typed columns from a sample, and store it under
+     * the connection. `models()` then emits one typed table per kind. Best-effort — returns null
+     * when the server exposes nothing modelable (the caller keeps the flat `mcp_items` fallback).
+     * `prefix` namespaces the tables (the server brand, e.g. `justworks`).
      */
-    constructor(clientFactory?: (creds: TrelloCreds) => Promise<TrelloClient>, credsLoader?: (connectionId: string) => TrelloCreds | null);
+    introspect(connectionId: string, toolkit: string, prefix: string): Promise<McpSchemaDescriptor | null>;
+    listChanges(toolkit: string, model: string, ctx: ListChangesContext): AsyncIterable<ExternalRecord>;
+}
+/** Build an introspective connector for a specific provider (branded, pre-pointed). */
+declare function introspectiveConnector(spec: IntrospectiveSpec, deps?: McpConnectorDeps): IntrospectiveMcpConnector;
+/** The generic MCP connector — point it at any reachable MCP server (no default url). */
+declare function genericConnector(deps?: McpConnectorDeps): IntrospectiveMcpConnector;
+
+/**
+ * The external-database connector — a {@link CredentialConnector} that connects to
+ * an external Postgres-family database (AWS RDS Postgres, Supabase, generic
+ * Postgres) the user supplies via host/user/password fields (read-only by
+ * contract — see external-pool.ts; raw connection strings are not accepted), and
+ * IMPORTS its tables into Lattice as connected data types (so they land in the
+ * SOURCE·INPUTS tier and sync via the shared connector sync engine).
+ *
+ * Unlike single-connection connectors (Jira/Trello), each external DB is its own
+ * connection with its own table set, so the toolkit string is per-connection
+ * (`db_source:<connectionId>`) and the dedicated `/api/db-sources` route creates a
+ * new registry row per connection. The credentials (connection string) + the
+ * introspected schema descriptor are persisted in the machine-local encrypted
+ * store — never in the registry, responses, or logs.
+ */
+
+/** Read the stored connection string for a connection, or null. */
+declare function getDbSourceCreds(connectionId: string): string | null;
+/** Persist the connection string (machine-local, encrypted). */
+declare function setDbSourceCreds(connectionId: string, connectionString: string): void;
+/** Remove the stored connection string. */
+declare function clearDbSourceCreds(connectionId: string): void;
+/**
+ * Assemble a Postgres connection string from host + user + database (+ optional
+ * port/password). Raw connection strings are deliberately NOT accepted: pasting a
+ * full URL invites reusing an owner/admin connection wholesale, and the read-only
+ * data-source contract wants the credentials entered deliberately (ideally a
+ * read-only database user). Throws loudly when incomplete — never a silent default.
+ */
+declare function assembleConnectionString(creds: Record<string, string>): string;
+declare class DatabaseConnector implements CredentialConnector {
+    private readonly credsLoader;
+    readonly connector = "db_source";
+    /** @param credsLoader test seam — resolve a connection id to its connection string. */
+    constructor(credsLoader?: (connectionId: string) => string | null);
     toolkits(): string[];
     models(toolkit: string): ConnectedModelDef[];
-    presentation(toolkit: string): ToolkitPresentation;
+    presentation(_toolkit: string): ToolkitPresentation;
     credentialFields(): CredentialField[];
-    helpUrl(): string;
-    /**
-     * Trello authenticates with a direct API key + token, not an OAuth redirect.
-     * The GUI collects them and calls {@link connect}; these SPI methods are
-     * therefore not part of the Trello flow and reject with a clear error.
-     */
+    helpUrl(): string | undefined;
     authorize(_userId: string, _toolkit: string): Promise<AuthorizeResult>;
     completeAuth(_userId: string, _toolkit: string): Promise<ConnectionResult>;
     /**
-     * Validate Trello credentials (`GET /members/me`) and, on success, store them
-     * encrypted under a fresh connection id. Returns the connection id (recorded in
-     * the registry by the caller) and the validated member's full name (for the
-     * UI). Throws if the credentials are invalid or absent.
+     * Validate the credentials against the external DB (`SELECT 1`), introspect its
+     * schema, and persist both the connection string + schema descriptor encrypted
+     * under a fresh connection id. Returns the id (recorded in the registry by the
+     * caller) and the database name as the display name.
      */
     connect(creds: Record<string, string>): Promise<{
         connectionId: string;
         displayName: string | null;
     }>;
-    listChanges(toolkit: string, model: string, ctx: ListChangesContext): AsyncIterable<ExternalRecord>;
-    disconnect(connectionId: string): Promise<void>;
     /**
-     * Cursor-paged fetch for Trello's newest-first list endpoints: pass the oldest
-     * id seen on the previous page as `before` to walk backwards. Stops on a short
-     * page; throws past {@link MAX_PAGES} to avoid an unbounded loop.
+     * Re-authenticate an EXISTING connection with edited credentials (e.g. a rotated
+     * password or a corrected host/port). Unlike {@link connect}, this reuses the
+     * connection id AND the descriptor's original table prefix, so the imported
+     * tables keep their physical names and rows upsert idempotently onto the same
+     * objects — an edit re-points the same database, it does not fork a new table
+     * set. Validates against the DB, re-introspects (picking up any newly-added
+     * tables), and overwrites the stored connection string + schema descriptor.
      */
-    private pageBefore;
+    reconnect(connectionId: string, creds: Record<string, string>): Promise<{
+        connectionId: string;
+        displayName: string | null;
+    }>;
+    listChanges(toolkit: string, model: string, ctx: ListChangesContext): AsyncIterable<ExternalRecord>;
+    disconnect(connectionId: string): Promise<void>;
 }
 
 /**
- * Trello connected data types — the eleven tables the Trello connector syncs.
- *
- * Pure schema: each model's Lattice {@link TableDefinition} (with a `source`
- * descriptor), its natural key (a stable Trello id = the primary key, so re-syncs
- * upsert idempotently), and the FK relations that derive graph edges. The
- * fetch/map logic lives in the connector ({@link TrelloConnector}), which calls
- * the Trello REST API directly over the Node global `fetch` — there is no broker
- * and no SDK dependency.
+ * SQL dialects for the external-database connector. A dialect knows how to (a)
+ * introspect a schema (tables → columns → primary keys), (b) map a native column
+ * type to a Lattice column spec, and (c) build a bounded page query. v5.0 ships
+ * Postgres-family support only; the interface is structured so MySQL/Snowflake can
+ * slot in later without touching the connector.
  *
- * Trello's members-on-a-board and members/labels-on-a-card relationships are
- * many-to-many, and `graphEdges` derives one edge per single FK column. So those
- * relationships are modeled as junction tables (`trello_board_members`,
- * `trello_card_members`, `trello_card_labels`) whose composite-key rows each
- * carry the two FK columns that produce real graph edges. A flat
- * `trello_members` identity table holds member profiles (Trello has no global
- * member list, so members are discovered per board).
+ * All introspection/page SQL is parameterized or built from identifiers this
+ * module quotes — never string-interpolated user values.
+ */
+/** A SQL fragment plus its bound parameters (Postgres `$1` placeholders). */
+interface SqlQuery {
+    sql: string;
+    params: unknown[];
+}
+/** Options for a bounded page over one external table. */
+interface PageOpts {
+    schema: string;
+    table: string;
+    /** Explicitly projected columns (never `SELECT *` — bounded reads). */
+    columns: string[];
+    /** Single-column key to keyset-paginate on, or null to offset-paginate. */
+    keyCol: string | null;
+    /** Last key value seen (keyset only); undefined for the first page. */
+    afterKey?: unknown;
+    /** Row offset (offset pagination only). */
+    offset: number;
+    /** Page size. */
+    limit: number;
+}
+interface SqlDialect {
+    readonly id: 'postgres';
+    /** True when this dialect handles the given connection string. */
+    detect(connectionString: string): boolean;
+    /** Quote an identifier (table/column/schema) for this dialect. */
+    quoteIdent(id: string): string;
+    /** List base tables in a schema → rows `{ name }`. */
+    tablesSql(schema: string): SqlQuery;
+    /** All columns for a schema → rows `{ table, name, type }` (ordinal order). */
+    columnsSql(schema: string): SqlQuery;
+    /** Primary-key columns for a schema → rows `{ table, col }` (key order). */
+    primaryKeysSql(schema: string): SqlQuery;
+    /**
+     * FOREIGN KEY columns for a schema → rows `{ cname, table, col, ref_table,
+     * ref_col }`. May emit multiple rows per composite constraint — the caller
+     * groups by `cname` and keeps single-column FKs only (those are the ones that
+     * map cleanly onto graph edges).
+     */
+    foreignKeysSql(schema: string): SqlQuery;
+    /** Map a native column type to a Lattice column SQL spec (TEXT | INTEGER | REAL). */
+    mapType(nativeType: string): 'TEXT' | 'INTEGER' | 'REAL';
+    /** Build a bounded page query (keyset when keyCol set, else offset). */
+    pageSql(opts: PageOpts): SqlQuery;
+}
+/** Postgres-family dialect (AWS RDS Postgres, Supabase, generic Postgres). */
+declare const PostgresDialect: SqlDialect;
+/**
+ * Resolve the dialect for a connection string. v5.0 supports Postgres-family
+ * only; a non-Postgres URL throws a clear, actionable error — never a silent
+ * fallback.
+ */
+declare function dialectFor(connectionString: string): SqlDialect;
+
+/**
+ * Persisted + memoized schema descriptor for one external-DB connection. The
+ * connector's `models()` is SYNCHRONOUS (the SPI + sync engine call it inline),
+ * but introspecting an external DB is async — so introspection happens in the
+ * async `connect()`/refresh paths, persists the descriptor in the machine-local
+ * encrypted store (alongside the credentials), and `models()` reads it back
+ * synchronously here. No schema migration: this rides the existing encrypted
+ * credential store, not the registry table.
  */
 
-/** All eleven Trello connected models, in dependency order (parents before children). */
-declare const TRELLO_MODELS: ConnectedModelDef[];
+interface DbColumnDesc {
+    /** External column name. */
+    name: string;
+    /** Mapped Lattice column spec. */
+    sqlSpec: 'TEXT' | 'INTEGER' | 'REAL';
+}
+interface DbTableDesc {
+    /** External table name within the source schema. */
+    name: string;
+    columns: DbColumnDesc[];
+    /** Primary-key columns in key order (may be empty for a keyless table). */
+    pk: string[];
+    /** Whether this table is imported (table-level selection). */
+    selected: boolean;
+    /**
+     * Single-column FOREIGN KEYs introspected from the remote (composite FKs are
+     * dropped at introspection time). Materialized as graph edges between the
+     * imported tables so a connected database's relational structure carries over.
+     * Optional — descriptors persisted before FK introspection existed lack it.
+     */
+    fks?: {
+        column: string;
+        refTable: string;
+        refColumn: string;
+    }[];
+}
+interface DbSchemaDescriptor {
+    dialect: string;
+    /** Source schema (e.g. `public`). */
+    schema: string;
+    /** Sanitized slug namespacing the imported Lattice tables (from the display name). */
+    prefix: string;
+    tables: DbTableDesc[];
+}
+declare function getSchemaDescriptor(connectionId: string): DbSchemaDescriptor | null;
+declare function setSchemaDescriptor(connectionId: string, descriptor: DbSchemaDescriptor): void;
+declare function clearSchemaDescriptor(connectionId: string): void;
+/** Lowercase, non-alphanumeric→underscore slug, bounded; never empty. */
+declare function slugify(name: string): string;
+/** The imported Lattice table name for an external table (namespaced by prefix). */
+declare function latticeTableName(prefix: string, externalTable: string): string;
 /**
- * Define the eleven Trello connected tables on a live database (post-init),
- * skipping any that already exist. Called before the first sync / on connector
- * setup.
+ * Build the Lattice {@link ConnectedModelDef}s for the selected tables. Pure +
+ * synchronous so `models()` can return immediately. Each table maps to a Lattice
+ * table carrying the standard lifecycle/lineage columns + the external columns,
+ * with a `source` descriptor (so the row stamps land it in the SOURCE·INPUTS tier).
  */
-declare function defineTrelloTables(db: Lattice): Promise<void>;
+declare function buildModelDefs(connectionId: string, descriptor: DbSchemaDescriptor): ConnectedModelDef[];
 
 /**
  * Connector sync engine.
@@ -5774,6 +7186,21 @@ declare function enableConnectorRls(db: Lattice, connector: Connector, toolkit:
  */
 declare function secureConnectorTables(db: Lattice, connector: Connector): Promise<void>;
 
+/**
+ * A compact summary of the workspace's connected external sources for the
+ * assistant's context, so it can answer "are you connected to X?" and knows
+ * which table holds each source's data. Returns '' when nothing is connected.
+ *
+ * On a CLOUD (Postgres) workspace this is scoped by `connectedBy` so a member
+ * never sees another member's connections. On a LOCAL (SQLite) single-user
+ * workspace the `connected_by` stamp is meaningless and can drift when the
+ * user's saved identity changes (a connector stamped with an old email would
+ * then be invisible), so every connection is listed — matching how the sidebar
+ * re-registers connector tables locally. This is the same trust boundary: a
+ * local workspace is one user's own machine.
+ */
+declare function describeConnectedSources(db: Lattice, connectedBy: string): Promise<string>;
+
 /**
  * Durable retry for transient database failures.
  *
@@ -6134,6 +7561,11 @@ interface UserIdentity {
  * Read the machine-local user identity. Returns `{display_name: '',
  * email: ''}` if the file is missing or malformed — callers can treat
  * empty fields as "not set yet" without a separate existence check.
+ *
+ * In a managed/hosted deployment there is no local identity file, so a stored
+ * field falls back to the `LATTICE_USER_NAME` / `LATTICE_USER_EMAIL` env vars
+ * (which the host injects per session). Env is only a fallback — a value written
+ * to the identity file always wins, preserving the "empty = not set" contract.
  */
 declare function readIdentity(): UserIdentity;
 /**
@@ -6169,6 +7601,15 @@ interface UserPreferences {
      * A user preference, machine-local (see `voice_provider`).
      */
     aggressiveness: number;
+    /**
+     * Clarify threshold (0..1) — the single confidence bar that decides when an
+     * automated inference asks the user instead of guessing. At or above the
+     * threshold the system acts silently; between the floor (threshold / 2,
+     * derived where consumed) and the threshold it asks a short multiple-choice
+     * question; below the floor it drops the inference as noise. A user
+     * preference, machine-local (see `voice_provider`).
+     */
+    clarify_threshold: number;
 }
 /**
  * Read machine-local user preferences. Returns defaults if the file is
@@ -6628,14 +8069,14 @@ declare function hasVectorIndex(adapter: StorageAdapter, table: string): Promise
  *   true — surfacing a misconfiguration loudly rather than silently doing
  *   nothing. By default it is a reported no-op (returns 0).
  */
-declare function buildVectorIndex(adapter: StorageAdapter, table: string, dim: number, requireExtension?: boolean): Promise<number>;
-/** Drop a table's native vector index. */
+declare function buildVectorIndex(adapter: StorageAdapter, table: string, dim: number, requireExtension?: boolean, opts?: VectorIndexOptions): Promise<number>;
+/** Drop a table's native vector index (and its registry row). */
 declare function dropVectorIndex(adapter: StorageAdapter, table: string): Promise<void>;
 /**
  * Query the native vector index for the nearest chunks to `queryVector`.
  * Returns up to `limit` hits with cosine similarity scores ≥ `minScore`.
  */
-declare function searchVectorIndex(adapter: StorageAdapter, table: string, queryVector: number[], limit: number, minScore: number): Promise<VectorHit[]>;
+declare function searchVectorIndex(adapter: StorageAdapter, table: string, queryVector: number[], limit: number, minScore: number, efSearch?: number): Promise<VectorHit[]>;
 
 /**
  * Reference-ingestion API — parallel to {@link attachBlob}, but records a row
@@ -6907,6 +8348,16 @@ declare function memberRoleName(label: string): string;
  * `postgres://<role>:<password>@<host>/<db>` and sees only its permitted rows.
  */
 declare function provisionMemberRole(db: Lattice, role: string, password: string): Promise<void>;
+/**
+ * Idempotently grant an EXISTING scoped login role membership in the cloud's
+ * member group. The group holds every table/schema/connect grant and RLS keys on
+ * `session_user`, so the role gets exactly an invited member's access while
+ * staying RLS-confined to its own rows. Use this to adopt a role created out of
+ * band (e.g. by an external provisioner) without rotating its password or
+ * re-running CREATE/ALTER ROLE. The member group must already exist (it is created
+ * when the owner first opens/secures the cloud).
+ */
+declare function grantMemberAccess(db: Lattice, role: string): Promise<void>;
 /**
  * Change a row's sharing through the owner-only `lattice_set_row_visibility`
  * SECURITY DEFINER function. Only the row's owner (Postgres raises for anyone
@@ -7254,6 +8705,9 @@ interface ClaudeAuth {
     apiKey?: string | undefined;
     authToken?: string | undefined;
     betaHeader?: string | undefined;
+    /** Override the Anthropic API host (the SDK's `baseURL`). Needed for a BYO custom-host key
+     *  or a proxy; when unset the SDK reads `process.env.ANTHROPIC_BASE_URL` or the default host. */
+    baseURL?: string | undefined;
 }
 
 /** Generate a 1-2 sentence description of a document's text. */
@@ -7291,6 +8745,20 @@ interface ExtractedObject {
     values: Record<string, string>;
     /** Short human label for the object. */
     label: string;
+    /**
+     * The model's 0-1 confidence in its target-entity decision (that {@link entity}
+     * is where these records belong / that a new entity is warranted). Optional:
+     * a model that omits it is treated by consumers as fully confident (1.0), so
+     * pre-confidence outputs behave exactly as before.
+     */
+    confidence?: number;
+    /**
+     * Labels of the OTHER extracted objects in the same document this object is
+     * related to — e.g. a meeting lists its attendees' labels. Consumers materialize
+     * these as record-to-record links (so a meeting links to its people, not just to
+     * the source). Optional: absent/empty → no cross-object links.
+     */
+    links?: string[];
 }
 /** Parse + sanitize the extractor's JSON. Caps at 3 objects; drops invalid ones. */
 declare function parseObjects(raw: string): ExtractedObject[];
@@ -7471,6 +8939,9 @@ interface VisionOptions {
     prompt?: string;
     /** Cap on the normalized JPEG size (bytes). Default ~1.4 MB. */
     maxBytes?: number;
+    /** The image's original media type (e.g. `image/png`). Used for the sharp-free fallback when
+     *  native normalization is unavailable — we send the raw bytes with this exact media type. */
+    mediaType?: string;
     /** Injectable model call (test seam). Defaults to a real Anthropic vision call. */
     sender?: (input: VisionSenderInput) => Promise<string>;
 }
@@ -7495,8 +8966,14 @@ interface PdfOptions {
  */
 declare function describePdf(auth: ClaudeAuth, path: string, opts?: PdfOptions): Promise<string>;
 
-/** How the running copy of the package was installed. */
-type InstallKind = 'global' | 'local' | 'npx' | 'linked-dev' | 'unknown';
+/**
+ * How the running copy of the package was installed. `desktop` is the bundled
+ * desktop app (a compiled binary, not an npm install): it is never
+ * `installable` via npm, but it CAN update itself through its own bundled
+ * updater, so the GUI surfaces a "restart to update" action for it rather than
+ * the npm "upgrade in place" action.
+ */
+type InstallKind = 'global' | 'local' | 'npx' | 'linked-dev' | 'unknown' | 'desktop';
 interface InstallContext {
     kind: InstallKind;
     /** True only when an `npm install` may safely upgrade this copy in place. */
@@ -7514,6 +8991,19 @@ interface UpdateStatus {
     latest: string | null;
     kind: InstallContext['kind'];
     installable: boolean;
+    /** Master switch — false when auto-update is disabled for this server. */
+    autoUpdate: boolean;
+    /**
+     * What the user can DO about an available update on THIS surface:
+     *  - `upgrade-in-place`: an npm install can upgrade this copy now (the GUI's
+     *    manual "Upgrade" fallback to the background poll).
+     *  - `restart-to-update`: a newer version exists and the bundled desktop
+     *    updater can apply it on relaunch ("Restart to update").
+     *  - `none`: nothing to offer — already current, auto-update disabled, or a
+     *    surface that can't self-update (a dev/linked checkout, where `latest` is
+     *    still reported for information but there is no apply action).
+     */
+    action: 'upgrade-in-place' | 'restart-to-update' | 'none';
     checking: boolean;
     installing: boolean;
     lastError: string | null;
@@ -7526,6 +9016,80 @@ interface UpdateService {
     checkNow(force?: boolean): Promise<UpdateStatus>;
 }
 
+/**
+ * Server-Sent Events protocol shared by the assistant chat stream and the
+ * activity feed. The server writes `data: <json>\n\n` frames; the browser
+ * reads them with a `fetch` ReadableStream reader. Both ends agree on the
+ * event shapes defined here so neither side has to guess.
+ */
+/** Events emitted while streaming one assistant turn (with tool calls). */
+type ChatStreamEvent = {
+    type: 'assistant_message_start';
+    id: string;
+} | {
+    type: 'text_delta';
+    delta: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+} | {
+    type: 'tool_result';
+    toolUseId: string;
+    isError: boolean;
+} | {
+    type: 'open';
+    table: string;
+    id: string;
+} | {
+    type: 'question';
+    question: string;
+    options: string[];
+    allowOther: boolean;
+} | {
+    type: 'assistant_message_end';
+    hadTools?: boolean;
+} | {
+    type: 'ack';
+    message: string;
+} | {
+    type: 'done';
+} | {
+    type: 'warn';
+    message: string;
+} | {
+    type: 'limit';
+    message: string;
+    resetAt?: string;
+} | {
+    type: 'error';
+    message: string;
+};
+
+/**
+ * In-process bus that streams ONE chat turn's progress to the GUI over the
+ * multiplexed `/api/stream` WebSocket — the async replacement for the held-open
+ * `POST /api/chat` SSE response. Modeled on {@link RenderProgressBus} / `FeedBus`,
+ * but deliberately with NO `latest()` / replay buffer: a reconnecting client recovers
+ * from the server-authoritative persisted `chat_messages` (checkpointed as the turn
+ * streams), so replaying stale ticks to a fresh socket would only cause double-render.
+ *
+ * Every envelope carries the turn's `ownerUserId` so the `/api/stream` forwarder can
+ * gate delivery PER USER — on a cloud workspace a chat is private to its author, and
+ * this bus is per-process (shared across every connected socket), so the gate is
+ * load-bearing, not decorative (see `chat-identity` / Stage 5).
+ */
+interface ChatProgressEnvelope {
+    /** The thread the turn belongs to. */
+    threadId: string;
+    /** The pending assistant message id — the client filters live events by (thread, message). */
+    messageId: string;
+    /** Cloud user id of the turn's owner; null on a local (single-user) workspace. */
+    ownerUserId: string | null;
+    /** The streamed chat event (same union the old SSE response wrote). */
+    event: ChatStreamEvent;
+}
+
 interface StartGuiServerOptions {
     /**
      * Active workspace config to open. NULL/empty ⇒ boot into the zero-workspace
@@ -7584,12 +9148,23 @@ interface StartGuiServerOptions {
      */
     realtimeWatchdogMs?: number;
     /**
-     * Run the in-process auto-update poll: while the GUI is open, check npm for a
+     * Master switch for ALL auto-update behavior (default true). When false: the
+     * in-process poll never runs (no registry/manifest fetch, no install, no
+     * relaunch), `/api/update/status` reports `autoUpdate:false` / `action:'none'`,
+     * and the desktop/CLI callers skip their own updaters too. Provided so the GUI
+     * can be run pinned to its current version (testing, air-gapped, reproducible
+     * demos). `GET /api/version` + `GET /api/update/status` still answer.
+     */
+    autoUpdate?: boolean;
+    /**
+     * Run the in-process auto-update poll: while the GUI is open, check for a
      * newer version and, when one lands on an installable copy, install it and
      * exit with the supervisor's restart code so it relaunches on the new version.
      * Set ONLY for a supervised child (`LATTICE_GUI_SUPERVISED=1`) — exiting to
-     * apply an update is safe only when a supervisor is there to respawn it.
-     * `GET /api/version` + `GET /api/update/status` are served regardless.
+     * apply an update is safe only when a supervisor is there to respawn it. This
+     * is the npm install-and-relaunch SUB-behavior; it is forced off when
+     * `autoUpdate` is false. `GET /api/version` + `GET /api/update/status` are
+     * served regardless.
      */
     selfUpdate?: boolean;
     /**
@@ -7599,6 +9174,29 @@ interface StartGuiServerOptions {
      * it overrides `selfUpdate`'s default factory.
      */
     updateServiceFactory?: (emit: (type: string, data: unknown) => void) => UpdateService;
+    /**
+     * Override the "is a newer version available?" probe. The desktop shell passes
+     * a function that reads its release manifest (latest.json) — the same source
+     * its bundled updater applies from — so the GUI surfaces a "restart to update"
+     * hint without coupling the desktop to the npm registry. Omitted ⇒ the default
+     * npm-registry check (web/CLI).
+     */
+    updateCheck?: (force: boolean) => Promise<string | null>;
+    /**
+     * Override the detected install context for the update service. The desktop
+     * shell passes `{ kind:'desktop', installable:false, … }` so the status route
+     * reports the desktop surface (→ `action:'restart-to-update'`) rather than
+     * "unknown / not installable".
+     */
+    updateContext?: InstallContext;
+    /**
+     * Desktop shell only: apply a pending update via the bundled binary updater
+     * (download + relaunch). Wired to `POST /api/update/apply` when the surface is
+     * the desktop app, so the "Restart to update" pill triggers the real updater
+     * instead of the npm install path (which the desktop can't use). Omitted ⇒ the
+     * apply route uses the npm path / reports "not available".
+     */
+    desktopApplyUpdate?: () => void;
     /**
      * Desktop shell only: open an external URL in the OS default browser. The
      * embedded desktop webview has no tabs, so `target="_blank"` links are routed
@@ -7622,6 +9220,12 @@ interface GuiServerHandle {
      * resolves immediately for a non-cloud / virgin workspace.
      */
     whenConverged: () => Promise<void>;
+    /**
+     * TEST-ONLY: publish a chat-progress envelope directly into the active workspace's bus so
+     * the per-user `/api/stream` delivery gate can be exercised without a live model turn.
+     * Never invoked in production.
+     */
+    publishChatProgressForTest: (env: ChatProgressEnvelope) => void;
 }
 declare function startGuiServer(options: StartGuiServerOptions): Promise<GuiServerHandle>;
 
@@ -7760,6 +9364,14 @@ interface ProposedSchema {
     entities: InferredEntity[];
     dimensions: InferredDimension[];
     linkages: InferredLinkage[];
+    /**
+     * Link candidates in the marginal confidence band — at or above the "drop as
+     * noise" floor but below the creation threshold (see `InferOptions.
+     * minLinkConfidence`). NOT materialized: the referencing column survives as a
+     * plain scalar column, and the importer asks the user whether to connect it
+     * instead of guessing. Same shape as {@link linkages}, confidence included.
+     */
+    marginalLinks: InferredLinkage[];
     /** Top-level keys not imported (derived rollups, meta, scalars, column dictionaries). */
     skipped: {
         key: string;
@@ -7801,6 +9413,16 @@ declare function inferFieldType(values: unknown[]): InferredType;
 interface InferOptions {
     /** Override the inferred entity → table name (sourceKey → name). */
     rename?: Record<string, string>;
+    /**
+     * Confidence bar for creating a linkage (0..1, clamped). At or above it a
+     * link is inferred as usual; in `[minLinkConfidence / 2, minLinkConfidence)`
+     * the candidate is returned on {@link ProposedSchema.marginalLinks} instead
+     * of being created (the referencing column stays a plain scalar column so a
+     * later confirmation can still connect it); below the floor it is dropped as
+     * noise. Dimension links (confidence 1) are unaffected. Defaults to
+     * {@link DEFAULT_LINK_CONFIDENCE}.
+     */
+    minLinkConfidence?: number;
 }
 declare function inferSchema(data: Record<string, unknown>, opts?: InferOptions): ProposedSchema;
 
@@ -8016,4 +9638,4 @@ declare function dedupeAndDetectViews(plan: ProposedSchema, data: Record<string,
     views: DetectedView[];
 };
 
-export { ALL_PROVENANCE_FIELDS, type AddWorkspaceOptions, type AdoptNativeOptions, type AdoptResult, type AggregateFunction, type AggregateHaving, type AggregateOptions, type AggregateResult, type AggregateSpec, type ApplyWriteResult, type AsOfCandidate, type AsOfColumnCandidate, type AsOfInputs, type AudienceRowCtx, type AuditEvent, type AuthorizeResult, type AutoUpdateResult, type BacklinkSignal, type BelongsToRelation, type BelongsToSource, type BenchmarkOptions, type BenchmarkReport, type BenchmarkScale, type BlobMetadata, BoundedReadError, type BuiltinTemplateName, CLOUD_SETTING_SYSTEM_PROMPT, CLOUD_SETTING_WORKSPACE_LOGO, CLOUD_SETTING_WORKSPACE_LOGO_ETAG, CONFIG_SUBDIR, CONNECTED_COLUMNS, CONNECTORS_TABLE, type CatalogEntity, type CatalogRecord, type ChangeEntry, type ChangelogOptions, type ChunkedMigrationOptions, type ChunkedMigrationResult, type ChunkerFn, type ClassifyMatch, type CleanupOptions, type CleanupResult, type CloudProbeResult, type CloudS3Secret, ComputedColumnCycleError, type ComputedColumnSpec, type ConnectedEdgeSpec, type ConnectedModelDef, ConnectedSourceImmutableError, type ConnectedVisibility, type ConnectionResult, type Connector, type ConnectorRecord, type ConnectorSource, type ConnectorStatus, ConnectorUnavailableError, type CountOptions, type CrawlOptions, type CrawlResult, type CreateConnectorInput, type CredentialConnector, type CredentialField, type CustomSignal, type CustomSource, DEFAULT_ENTRY_TYPES, DEFAULT_MAX_NODES, DEFAULT_STALE_MS, DEFAULT_TYPE_ALIASES, DenoSqliteAdapter, type DetectedView, type DiagnoseOptions, type DisconnectOptions, type DisconnectResult, type DiscoveredTable, EMBEDDINGS_TABLE, EmbeddingDimensionMismatchError, type EmbeddingRefreshResult, EmbeddingScanTooLargeError, type EmbeddingsConfig, type EnrichOptions, type EnrichResult, type EnrichedSource, type EnrichmentLookup, type EntityContextDefinition, type EntityContextManifestEntry, type EntityFileManifestInfo, type EntityFileSource, type EntityFileSpec, type EntityMatch, type EntityProfileField, type EntityProfileSection, type EntityProfileTemplate, type EntityRenderSpec, type EntityRenderTemplate, type EntitySectionPerRow, type EntitySectionsTemplate, type EntityTableColumn, type EntityTableTemplate, type EvalQuery, type EvalRegression, type ExistingTable, type ExtensionAvailability, type ExternalRecord, type ExtractEdgesSpec, type ExtractedObject, FileSourceKeyStore, type FileSourceKeyStoreOptions, type FilesRow, type Filter, type FilterAnd, type FilterExpr, type FilterOp, type FilterOr, FoldCache, type FtsConfig, type FtsGroup, type FtsHit, type FtsOptions, type FtsResult, type GraphBoostOptions, type GraphBoostResult, type GraphEdge, type GraphNode, type GraphTraversalResult, type GuiServerHandle, type HasManyRelation, type HasManySource, type HealthIssueKind, type HealthSeverity, type HybridScoreBreakdown, type HybridSearchOptions, type HybridSearchResult, IMMUTABLE_CONNECTED_FIELDS, type ImportMode, type ImportProgress, InMemorySourceKeyStore, InMemoryStateStore, type InferredColumn, type InferredDimension, type InferredEntity, type InferredLinkage, type InferredType, type InitOptions, JIRA_MODELS, type JiraClient, JiraConnector, type JiraCreds, LEGACY_MEMBER_GROUP, LOCAL_DB_RELPATH, type LatencyStats, Lattice, type LatticeConfig, type LatticeConfigInput, type LatticeEntityDef, type LatticeEntityRenderSpec, type LatticeFieldDef, type LatticeFieldType, type LatticeManifest, type LatticeOptions, type LinkOptions, type ListChangesContext, type LlmClient, type LlmMessage, MAX_TRAVERSAL_DEPTH, type ManyToManySource, type MarkdownTableColumn, type MaterializeCtx, type MaterializeOptions, type MaterializeResult, type MaterializedRollupSpec, type MigrateResult, type Migration, type MigrationCheckpoint, type MigrationOptions, type MigrationProgress, type MigrationResult, type MigrationStatus, type MultiTableDefinition, NATIVE_ENTITY_DEFS, NATIVE_ENTITY_NAMES, NATIVE_REGISTRY_TABLE, type Observation, type OrderBySpec, type OrganizeOptions, type OrganizeResult, type OrganizedCreation, type OrganizedLink, type ParseError, type ParseResult, type ParsedConfig, type PdfOptions, type PdfSenderInput, type PerQueryEval, type PkLookup, PostgresAdapter, type PostgresAdapterOptions, type PreparedStatement, type PrimaryKey, ProgressThrottle, type ProposedSchema, type ProvenanceConfig, type ProvenanceField, ProvenanceImmutableError, type QueryOptions, type QueryPageOptions, type QueryPageResult, type QueryProjection, READ_ONLY_HEADER, ROOT_DIRNAME, type RankingOptions, type ReadOnlyHeaderOptions, type RecencySignal, type ReconcileOptions, type ReconcileResult, type RefKind, type RefProvider, type ReferenceMetadata, ReferenceUnavailableError, type RefreshEmbeddingsOptions, type Relation, type RelevanceLabel, type RemoteBlobStore, type RenderHooks, type RenderOptions, type RenderProgress, type RenderProgressCallback, type RenderProgressKind, type RenderResult, type RenderSpec, type ReportConfig, type ReportResult, type ReportSection, type ReportSectionResult, type RerankCandidate, type RerankScore, type RerankerFn, type ResolveOptions, type RetrievalEvalOptions, type RetrievalEvalSummary, type RetrievalHealthIssue, type RetrievalHealthReport, type RetrievalHealthSpec, type RetrievalSlo, type Retriever, type RetryOptions, type ReverseSeedDetection, type ReverseSeedResult, type ReverseSeedTableResult, type ReverseSyncError, type ReverseSyncResult, type ReverseSyncUpdate, type RewardScores, type RewardSignal, type RollupFunction, type Row, type RowVisibilityDefault, type S3Config, type S3StoreConfig, S3UnavailableError, S3_SECRET_TABLE, SQLiteAdapter, type SchemaEntity, type SchemaMatch, type SearchOptions, type SearchResult, type SecurityOptions, type SeedConfig, type SeedLinkSpec, SeedReconciliationError, type SeedResult, type SelfSource, type SemanticChunkerOptions, type SessionEntry, type SessionParseOptions, type SessionWriteEntry, type SessionWriteOp, type SessionWriteParseResult, type SloViolation, type SourceHandle, type SourceKeyStore, type SourceMetadata, type SourceQueryOptions, SourceShreddedError, type StartGuiServerOptions, type StopFn, type StorageAdapter, type SyncConnectorOptions, type SyncConnectorResult, type SyncResult, TRELLO_MODELS, TRUST_COLUMNS, type TableDefinition, type TableHealth, type TablePolicy, type TemplateRenderSpec, type TextChunk, type ToolkitPresentation, type TraversalDirection, type TraversalNode, type TraversalOptions, type TrelloClient, TrelloConnector, type TrelloCreds, type TrelloPageOpts, type TrustConfig, type TrustState, type TurnParams, type TurnResult, type UnresolvedLink, type UpsertByNaturalKeyOptions, type UserIdentity, type UserPreferences, type VectorHit, type Viewer, type VisionOptions, type VisionSenderInput, WORKSPACES_SUBDIR, type WatchOptions, type WorkspacePaths, type WorkspaceRecord, type WorkspaceRegistry, type WriteHook, type WriteHookContext, type WritebackDefinition, type WritebackStateStore, type WritebackValidationResult, activeWorkspaceLabel, addEdge, addEdges, addWorkspace, adoptNativeEntities, allComputedDeps, analyticsEnabled, applyChunkedMigration, applyReranker, applyTokenBudget, applyWriteEntry, archiveLocalSqlite, assertSafeUrl, attachBlob, audiencePredicate, audienceViewSql, autoFtsColumns, autoUpdate, backfillOwnership, backlinkBoost, benchmarkRetrieval, buildVectorIndex, builtinConnectors, canManageRoles, checkSlos, chunkText, classifyLinks, clearJiraCreds, clearTrelloCreds, cloudRlsInstalled, collectConnectorKeys, computeColumns, computedColumnDdl, computedColumnOrder, concatRowText, configDir, connectedColumns, contentHash, cosineSimilarity, crawlUrl, createConnector, createReadOnlyHeader, createS3Store, createSQLiteStateStore, decrypt, dedupeAndDetectViews, defaultWorkspaceYaml, defineJiraTables, defineTrelloTables, deleteConnectorRecord, deleteDbCredential, deleteToken, deriveCanonicalContexts, deriveKey, describeImage, describePdf, detectAsOf, detectAsOfCandidates, detectAsOfColumns, detectRetrievalRegressions, diagnoseRetrieval, disconnectConnector, discoverCloudTables, dropVectorIndex, enableAudienceView, enableChangelogRls, enableConnectorRls, enableRlsForTable, encrypt, enrichKnowledge, ensureCheckpointTable, ensureConnectorRegistry, ensureEdgesTable, ensureEmbeddingsTable, ensureFtsIndex, ensureLatticeRoot, entityFileNames, estimateTokens, evaluateRetrieval, excelToRecords, extractEdgesFromColumn, extractObjects, filePresignSql, findLatticeRoot, fixSchemaConflicts, foldEntity, formatHealthReport, frontmatter, ftsTableName, fullTextSearch, generateEntryId, generateMemberPassword, generateWriteEntryId, getActiveWorkspace, getCloudSetting, getConnector, getConnectorByToolkit, getDbCredential, getJiraCreds, getMigrationCheckpoint, getOrCreateMasterKey, getTablePolicy, getTrelloCreds, getWorkspace, grantPresignerToMemberGroup, graphAdjacencyBoost, hasFilePresigner, hasFtsIndex, hasVectorIndex, hashFile, hybridSearch, importLegacyUserConfig, inferFieldType, inferSchema, installCloudRls, installCloudSettings, installFilePresigner, isCredentialConnector, isEncrypted, isNativeEntity, isPostgresUrl, isPrivateIp, isRetryableDbError, isRowAudience, latencyStats, listConnectors, listDbCredentials, listMigrationCheckpoints, listNativeBindings, listTokens, listWorkspaces, loadColumnPolicy, loadJiraClient, loadTrelloClient, manifestPath, markdownTable, matchSchemaToExisting, materializeImport, memberGroupFor, memberRoleName, migrateLatticeData, neighbors, normalizeName, observationVisible, observationsFromChange, openTargetLatticeForMigration, openUnderSource, organizeSource, parseCellDate, parseConfigFile, parseConfigString, parseMarkdownEntries, parseMatches, parseObjects, parseSessionMD, parseSessionWrites, percentile, probeCloud, provenanceColumns, providerForUrl, provisionMemberRole, rankingBoost, readIdentity, readManifest, readPreferences, readRegistry, readToken, recencyBoost, recordSync, referenceLocalFile, referenceUrl, refreshEmbeddings, regenerateAudienceViewFromDb, registerNativeEntities, registryPath, removeEdge, removeEmbedding, renameEntities, resolveActiveS3Config, resolveConnectorIdentity, resolveLatticeRoot, resolveProvenanceFields, resolveSource, resolveTrustDefault, resolveWorkspacePaths, resumeMigration, revertMigration, revokeMemberRole, rewardBoost, rollupColumnDdl, rootConfigDir, s3Key, saveDbCredential, saveDbCredentialForTeam, sealUnderSource, searchByEmbedding, searchVectorIndex, secureCloud, secureConnectorTables, seedColumnPolicyFromYaml, semanticChunker, setActiveWorkspace, setCloudS3Secret, setCloudSetting, setColumnAudience, setConnectorStatus, setJiraCreds, setRowVisibility, setTableDefaultVisibility, setTableNeverShare, setTrelloCreds, shredSource, slugify, sourceRecords, startGuiServer, storeEmbedding, summarizeText, syncConnector, syncIfStale, syncStaleConnectors, tableNeedsAudienceView, toSafeDirName, traverse, truncate, updateConnectorConnection, validateEntryId, vectorIndexAvailable, vectorIndexName, withRetry, workspaceBlobsDir, workspaceConfigPath, workspaceContextDir, workspaceDataDir, workspaceDbPath, workspaceDir, workspacesDir, writeIdentity, writeManifest, writePreferences, writeRegistry, writeToken };
+export { AI_CELL_TABLE, AI_MAP_TABLE, ALL_PROVENANCE_FIELDS, type AddWorkspaceOptions, type AdoptNativeOptions, type AdoptResult, type AggregateFunction, type AggregateHaving, type AggregateOptions, type AggregateResult, type AggregateSpec, type ApplyWriteResult, type AsOfCandidate, type AsOfColumnCandidate, type AsOfInputs, type AudienceRowCtx, type AuditEvent, type AuthorizeResult, type AutoUpdateResult, type BacklinkSignal, type BelongsToRelation, type BelongsToSource, type BenchmarkOptions, type BenchmarkReport, type BenchmarkScale, type BlobMetadata, type BoundedCountOptions, BoundedReadError, type BuiltinTemplateName, CLOUD_SETTING_SYSTEM_PROMPT, CLOUD_SETTING_WORKSPACE_LOGO, CLOUD_SETTING_WORKSPACE_LOGO_ETAG, COMPUTED_STATE_TABLE, CONFIG_SUBDIR, CONNECTED_COLUMNS, CONNECTORS_TABLE, type CalcEmitContext, type CalcExpr, CalcExprError, type CalcNode, type CalcRefResolver, type CatalogEntity, type CatalogRecord, type ChangeEntry, type ChangelogOptions, type ChunkedMigrationOptions, type ChunkedMigrationResult, type ChunkerFn, type ClassifyMatch, type CleanupOptions, type CleanupResult, type CloudProbeResult, type CloudS3Secret, type CompiledAiField, type CompiledComputedTable, ComputedColumnCycleError, type ComputedColumnSpec, type ComputedFieldDef, type ComputedFieldState, type ComputedFillOptions, type ComputedFillReport, type ComputedRegistrationResult, type ComputedSchema, type ComputedSchemaTable, ComputedTableCycleError, type ComputedTableDef, type ComputedTableHost, type ConnectedEdgeSpec, type ConnectedModelDef, ConnectedSourceImmutableError, type ConnectedVisibility, type ConnectionResult, type Connector, type ConnectorRecord, type ConnectorSource, type ConnectorStatus, ConnectorUnavailableError, type CountOptions, type CrawlOptions, type CrawlResult, type CreateConnectorInput, type CredentialConnector, type CredentialField, type CustomSignal, type CustomSource, DEFAULT_ENTRY_TYPES, DEFAULT_MAX_NODES, DEFAULT_STALE_MS, DEFAULT_TYPE_ALIASES, DatabaseConnector, type DbColumnDesc, type DbSchemaDescriptor, type DbTableDesc, DenoSqliteAdapter, type DetectedView, type DiagnoseOptions, type DisconnectOptions, type DisconnectResult, type DiscoveredTable, EMBEDDINGS_TABLE, EmbeddingDimensionMismatchError, type EmbeddingRefreshResult, EmbeddingScanTooLargeError, type EmbeddingsConfig, type EnrichOptions, type EnrichResult, type EnrichedSource, type EnrichmentLookup, type EntityContextDefinition, type EntityContextManifestEntry, type EntityFileManifestInfo, type EntityFileSource, type EntityFileSpec, type EntityMatch, type EntityProfileField, type EntityProfileSection, type EntityProfileTemplate, type EntityRenderSpec, type EntityRenderTemplate, type EntitySectionPerRow, type EntitySectionsTemplate, type EntityTableColumn, type EntityTableTemplate, type EvalQuery, type EvalRegression, type ExistingTable, type ExtensionAvailability, type ExternalRecord, type ExtractEdgesSpec, type ExtractedObject, type FieldFillResult, FileSourceKeyStore, type FileSourceKeyStoreOptions, type FilesRow, type FillLlm, type Filter, type FilterAnd, type FilterExpr, type FilterOp, type FilterOr, FoldCache, type FtsConfig, type FtsGroup, type FtsHit, type FtsOptions, type FtsResult, type GraphBoostOptions, type GraphBoostResult, type GraphEdge, type GraphNode, type GraphTraversalResult, type GuiServerHandle, type HasManyRelation, type HasManySource, type HealthIssueKind, type HealthSeverity, type HybridScoreBreakdown, type HybridSearchOptions, type HybridSearchResult, IMMUTABLE_CONNECTED_FIELDS, type ImportMode, type ImportProgress, InMemorySourceKeyStore, InMemoryStateStore, type InferredColumn, type InferredDimension, type InferredEntity, type InferredLinkage, type InferredType, type InitOptions, type IntrospectiveSpec, LEGACY_MEMBER_GROUP, LOCAL_DB_RELPATH, type LatencyStats, Lattice, type LatticeConfig, type LatticeConfigInput, type LatticeEntityDef, type LatticeEntityRenderSpec, type LatticeFieldDef, type LatticeFieldType, type LatticeManifest, type LatticeOptions, type LinkOptions, type ListChangesContext, type LlmClient, type LlmMessage, MAX_TRAVERSAL_DEPTH, type ManyToManySource, type MarkdownTableColumn, type MaterializeCtx, type MaterializeOptions, type MaterializeResult, type MaterializedRollupSpec, type McpBeginResult, type McpConnector, McpConnectorBase, type McpConnectorDeps, type McpConnectorSpec, type McpModelBinding, type McpOAuthDriver, type McpServerRef, type McpServerSpec, type McpToolCall, type McpToolInfo, type McpTransport, type McpTransportFactory, type MigrateResult, type Migration, type MigrationCheckpoint, type MigrationOptions, type MigrationProgress, type MigrationResult, type MigrationStatus, type MultiTableDefinition, NATIVE_ENTITY_DEFS, NATIVE_ENTITY_NAMES, NATIVE_REGISTRY_TABLE, type Observation, type OrderBySpec, type OrganizeOptions, type OrganizeResult, type OrganizedCreation, type OrganizedLink, type PageOpts, type ParseError, type ParseResult, type ParsedConfig, type PdfOptions, type PdfSenderInput, type PerQueryEval, type PkLookup, PostgresAdapter, type PostgresAdapterOptions, PostgresDialect, type PreparedStatement, type PrimaryKey, ProgressThrottle, type ProposedSchema, type ProvenanceConfig, type ProvenanceField, ProvenanceImmutableError, type QueryOptions, type QueryPageOptions, type QueryPageResult, type QueryProjection, READ_ONLY_HEADER, ROOT_DIRNAME, type RankingOptions, type ReadOnlyHeaderOptions, type RecencySignal, type ReconcileOptions, type ReconcileResult, type RefKind, type RefProvider, type ReferenceMetadata, ReferenceUnavailableError, type RefreshEmbeddingsOptions, type RegisterComputedTablesOptions, type Relation, type RelevanceLabel, type RemoteBlobStore, type RenderHooks, type RenderOptions, type RenderProgress, type RenderProgressCallback, type RenderProgressKind, type RenderResult, type RenderSpec, type ReportConfig, type ReportResult, type ReportSection, type ReportSectionResult, type RerankCandidate, type RerankScore, type RerankerFn, type ResolveOptions, type RetrievalEvalOptions, type RetrievalEvalSummary, type RetrievalHealthIssue, type RetrievalHealthReport, type RetrievalHealthSpec, type RetrievalSlo, type Retriever, type RetryOptions, type ReverseSeedDetection, type ReverseSeedResult, type ReverseSeedTableResult, type ReverseSyncError, type ReverseSyncResult, type ReverseSyncUpdate, type RewardScores, type RewardSignal, type RollupFunction, type Row, type RowVisibilityDefault, type S3Config, type S3StoreConfig, S3UnavailableError, S3_SECRET_TABLE, SQLiteAdapter, type SchemaEntity, type SchemaMatch, type SearchOptions, type SearchResult, type SecurityOptions, type SeedConfig, type SeedLinkSpec, SeedReconciliationError, type SeedResult, type SelfSource, type SemanticChunkerOptions, type SessionEntry, type SessionParseOptions, type SessionWriteEntry, type SessionWriteOp, type SessionWriteParseResult, SimpleMcpConnector, type SloViolation, type SourceHandle, type SourceKeyStore, type SourceMetadata, type SourceQueryOptions, SourceShreddedError, type SqlDialect, type SqlQuery, type StartGuiServerOptions, type StopFn, type StorageAdapter, type SyncConnectorOptions, type SyncConnectorResult, type SyncResult, TRUST_COLUMNS, type TableDefinition, type TableHealth, type TablePolicy, type TemplateRenderSpec, type TextChunk, type ToolkitPresentation, type TraversalDirection, type TraversalNode, type TraversalOptions, type TrustConfig, type TrustState, type TurnParams, type TurnResult, type UnresolvedLink, type UpsertByNaturalKeyOptions, type UserIdentity, type UserPreferences, type VectorHit, type VectorIndexOptions, type Viewer, type VisionOptions, type VisionSenderInput, WORKSPACES_SUBDIR, type WatchOptions, type WorkspacePaths, type WorkspaceRecord, type WorkspaceRegistry, type WriteHook, type WriteHookContext, type WritebackDefinition, type WritebackStateStore, type WritebackValidationResult, activeWorkspaceLabel, addEdge, addEdges, addWorkspace, adoptNativeEntities, allComputedDeps, analyticsEnabled, applyChunkedMigration, applyReranker, applyTokenBudget, applyWriteEntry, archiveLocalSqlite, assembleConnectionString, assertSafeUrl, attachBlob, audiencePredicate, audienceViewSql, autoFtsColumns, autoUpdate, backfillOwnership, backlinkBoost, benchmarkRetrieval, buildModelDefs, buildVectorIndex, builtinConnectors, canManageRoles, checkSlos, chunkText, classifyLinks, clearDbSourceCreds, clearSchemaDescriptor, cloudRlsInstalled, collectConnectorKeys, compileComputedTable, computeColumns, computedColumnDdl, computedColumnOrder, computedTableOrder, concatRowText, configDir, connectDirect, connectedColumns, contentHash, cosineSimilarity, crawlUrl, createConnector, createReadOnlyHeader, createS3Store, createSQLiteStateStore, decrypt, dedupeAndDetectViews, defaultWorkspaceYaml, deleteConnectorRecord, deleteDbCredential, deleteToken, deriveCanonicalContexts, deriveKey, describeConnectedSources, describeImage, describePdf, detectAsOf, detectAsOfCandidates, detectAsOfColumns, detectRetrievalRegressions, diagnoseRetrieval, dialectFor, disconnectConnector, discoverCloudTables, dropVectorIndex, emitCalcExpr, enableAudienceView, enableChangelogRls, enableConnectorRls, enableRlsForTable, encrypt, enrichKnowledge, ensureAiTables, ensureCheckpointTable, ensureConnectorRegistry, ensureEdgesTable, ensureEmbeddingsTable, ensureFtsIndex, ensureLatticeRoot, entityFileNames, estimateTokens, evaluateRetrieval, excelToRecords, extractEdgesFromColumn, extractObjects, filePresignSql, findLatticeRoot, fixSchemaConflicts, foldEntity, formatHealthReport, frontmatter, ftsTableName, fullTextSearch, generateEntryId, generateMemberPassword, generateWriteEntryId, genericConnector, getActiveWorkspace, getCloudSetting, getConnector, getConnectorByToolkit, getDbCredential, getDbSourceCreds, getMigrationCheckpoint, getOrCreateMasterKey, getSchemaDescriptor, getTablePolicy, getWorkspace, grantMemberAccess, grantPresignerToMemberGroup, graphAdjacencyBoost, hasFilePresigner, hasFtsIndex, hasVectorIndex, hashFile, hybridSearch, importLegacyUserConfig, inferFieldType, inferSchema, installCloudRls, installCloudSettings, installFilePresigner, introspectiveConnector, isCredentialConnector, isEncrypted, isMcpConnector, isNativeEntity, isPostgresUrl, isPrivateIp, isRetryableDbError, isRowAudience, latencyStats, latticeTableName, listConnectors, listDbCredentials, listMigrationCheckpoints, listNativeBindings, listTokens, listWorkspaces, loadColumnPolicy, manifestPath, markdownTable, matchSchemaToExisting, materializeImport, mcpModel, memberGroupFor, memberRoleName, migrateLatticeData, neighbors, normalizeName, observationVisible, observationsFromChange, openTargetLatticeForMigration, openUnderSource, organizeSource, parseCalcExpr, parseCellDate, parseConfigFile, parseConfigString, parseMarkdownEntries, parseMatches, parseObjects, parseSessionMD, parseSessionWrites, percentile, probeCloud, provenanceColumns, providerForUrl, provisionMemberRole, purgeAiField, rankingBoost, readComputedState, readIdentity, readManifest, readPreferences, readRegistry, readToken, recencyBoost, recordSync, referenceLocalFile, referenceUrl, refreshEmbeddings, regenerateAudienceViewFromDb, registerComputedTables, registerNativeEntities, registryPath, removeEdge, removeEmbedding, renameEntities, resolveActiveS3Config, resolveConnectorIdentity, resolveLatticeRoot, resolveProvenanceFields, resolveSource, resolveTrustDefault, resolveWorkspacePaths, resumeMigration, revertMigration, revokeMemberRole, rewardBoost, rollupColumnDdl, rootConfigDir, runComputedFill, s3Key, saveDbCredential, saveDbCredentialForTeam, sealUnderSource, searchByEmbedding, searchVectorIndex, secureCloud, secureConnectorTables, seedColumnPolicyFromYaml, semanticChunker, setActiveWorkspace, setCloudS3Secret, setCloudSetting, setColumnAudience, setConnectorStatus, setDbSourceCreds, setRowVisibility, setSchemaDescriptor, setTableDefaultVisibility, setTableNeverShare, shredSource, slugify$1 as slugify, slugify as slugifyDbName, sourceRecords, startGuiServer, storeEmbedding, summarizeText, syncConnector, syncIfStale, syncStaleConnectors, tableNeedsAudienceView, toSafeDirName, traverse, truncate, updateConnectorConnection, validateEntryId, vectorIndexAvailable, vectorIndexName, withRetry, workspaceBlobsDir, workspaceConfigPath, workspaceContextDir, workspaceDataDir, workspaceDbPath, workspaceDir, workspacesDir, writeIdentity, writeManifest, writePreferences, writeRegistry, writeToken };