latticesql 4.2.3 → 4.3.0

package/dist/index.d.ts

@@ -770,6 +770,72 @@ declare function chunkText(text: string, chunker?: ChunkerFn, contextPrefix?: st
     content: string;
 }[];
 
+/**
+ * Connected data types — tables backed by an external source via a connector.
+ *
+ * A table that declares `source` is a *connected data type*: its rows are
+ * ingested from an external system (e.g. issues from a project tracker) rather
+ * than authored locally. The framework stamps each row with bookkeeping that
+ * records which connector instance produced it and when, so the data can be
+ * re-synced idempotently, scoped per connector, and torn down completely when
+ * the connector is disconnected.
+ *
+ * The natural key (a stable external identifier — e.g. an issue key) is the
+ * table's primary key, so `upsert` is idempotent across re-syncs and the
+ * connector lineage columns are preserved on conflict.
+ *
+ * Lineage columns (`_source_connector_id`, `_source_model`) are immutable: once
+ * stamped at ingest they cannot be rewritten by `update()`, so a re-sync or a
+ * manual edit can't quietly relabel which connector a row came from. The
+ * sync-time bookkeeping column (`_source_synced_at`) is mutable.
+ *
+ * Opt-in per table; tables without a `source` add no columns and pay nothing.
+ */
+/** A row's connector lineage / sync bookkeeping. Mirrors the governance pattern. */
+declare const CONNECTED_COLUMNS: Record<string, string>;
+/**
+ * Lineage columns that may not be changed by `update()` after a row exists.
+ * `_source_synced_at` is intentionally excluded — it is re-stamped every sync.
+ */
+declare const IMMUTABLE_CONNECTED_FIELDS: readonly string[];
+/** Row visibility a connected table's rows default to when ingested into a cloud. */
+type ConnectedVisibility = 'private' | 'everyone';
+/**
+ * Declares a table as a connected data type (see module docs). Attached to a
+ * {@link TableDefinition} as `source`.
+ */
+interface ConnectorSource {
+    /** The connector implementation that backs this table (e.g. `'jira'`). */
+    connector: string;
+    /** The external product/toolkit (e.g. `'jira'`). */
+    toolkit: string;
+    /** The model within the toolkit (e.g. `'issue'`). */
+    model: string;
+    /**
+     * The column holding the stable external identifier. By convention this is
+     * the table's primary key, so re-syncs upsert idempotently on it.
+     */
+    naturalKey: string;
+    /**
+     * Default row visibility when ingested into a cloud workspace. `'private'`
+     * (the default) scopes rows to the connecting member; `'everyone'` shares
+     * them with all cloud members. Configurable per connected type.
+     */
+    defaultVisibility?: ConnectedVisibility;
+}
+/** The DDL column spec map a connected-data-type contributes. */
+declare function connectedColumns(source: ConnectorSource | undefined): Record<string, string>;
+/**
+ * Thrown when an `update()` tries to change an immutable connector-lineage
+ * column. Surfaced loudly so a row can't be silently relabeled to a different
+ * connector or model after ingest.
+ */
+declare class ConnectedSourceImmutableError extends Error {
+    readonly table: string;
+    readonly column: string;
+    constructor(table: string, column: string);
+}
+
 /**
  * Declarative computed columns + materialized rollups.
  *
@@ -1418,6 +1484,16 @@ interface TableDefinition {
      * `refreshMaterializedRollups`. See {@link MaterializedRollupSpec}.
      */
     materializedRollups?: Record<string, MaterializedRollupSpec>;
+    /**
+     * 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.
+     * Adds connector-lineage columns (`_source_connector_id`, `_source_model`,
+     * `_source_synced_at`); the first two are immutable (an `update()` touching
+     * them throws `ConnectedSourceImmutableError`). The GUI shows a "Connected"
+     * badge for these tables, and disconnecting the connector tears their rows
+     * down. Tables without a `source` are unaffected. See {@link ConnectorSource}.
+     */
+    source?: ConnectorSource;
 }
 interface MultiTableDefinition {
     /** Returns the "anchor" entities — one output file is produced per anchor */
@@ -3282,6 +3358,8 @@ declare class Lattice {
     private readonly _provenanceCols;
     /** table → default trust state for new rows (governance: P-TRUST). */
     private readonly _trustDefault;
+    /** table → connector source descriptor (connected data types, 4.3+). */
+    private readonly _connectedSources;
     /** table → computed-column specs + recompute order + dep set (P-VIEW). */
     private readonly _computed;
     /** table → materialized rollup specs (P-VIEW). */
@@ -3518,6 +3596,18 @@ declare class Lattice {
      * trust table. Returns a shallow copy; a no-op for tables without governance.
      */
     private _applyGovernanceDefaults;
+    /**
+     * Stamp connector defaults at insert time for a connected data type: default
+     * `_source_model` from the table's source descriptor and `_source_synced_at`
+     * to now, when not already supplied. A no-op for tables without a `source`.
+     * The connector sync engine normally sets these explicitly; this is the
+     * safety net for a direct insert into a connected table.
+     */
+    private _applyConnectedDefaults;
+    /** The connector source descriptor for a connected data type, or undefined. */
+    getConnectedSource(table: string): ConnectorSource | undefined;
+    /** Names of all registered connected data types (tables with a `source`). */
+    connectedTables(): string[];
     /** Post-insert side effects (changelog, audit, write hooks, embedding sync),
      *  identical for the plain and force-visibility insert paths. */
     private _afterInsert;
@@ -4764,6 +4854,74 @@ declare class SQLiteAdapter implements StorageAdapter {
     withClient<T>(fn: (tx: TxClient) => Promise<T>): Promise<T>;
 }
 
+/**
+ * SQLite adapter backed by the runtime's built-in `node:sqlite` `DatabaseSync`
+ * (synchronous) instead of the `better-sqlite3` native addon. This exists so
+ * Lattice can run under a runtime that ships `node:sqlite` but cannot load
+ * native N-API addons (the desktop build). The surface is a 1:1 mirror of the
+ * better-sqlite3 adapter — same StorageAdapter contract, same SQL — with three
+ * substitutions where the two SQLite bindings differ:
+ *
+ *   1. pragmas are issued via `exec()` (no `.pragma()` helper);
+ *   2. the `data_version` half of changeProbe is read with a plain
+ *      `PRAGMA data_version` statement (no `{ simple: true }` option);
+ *   3. BLOB columns read back as `Uint8Array` rather than `Buffer`. Lattice's
+ *      own file storage is disk-based (content-addressed blobs), so the core
+ *      never round-trips file bytes through a BLOB column; a user-defined
+ *      `blob` column consumed specifically as a Node `Buffer` is the only place
+ *      the difference is observable. `Buffer` is itself a `Uint8Array`, so byte
+ *      access is identical; only Buffer-only methods would differ.
+ */
+interface NodeSqliteRunResult {
+    changes: number | bigint;
+    lastInsertRowid: number | bigint;
+}
+interface NodeStatementSync {
+    run(...params: unknown[]): NodeSqliteRunResult;
+    get(...params: unknown[]): Row | undefined;
+    all(...params: unknown[]): Row[];
+}
+interface NodeDatabaseSync {
+    exec(sql: string): void;
+    prepare(sql: string): NodeStatementSync;
+    close(): void;
+}
+declare class DenoSqliteAdapter implements StorageAdapter {
+    readonly dialect: "sqlite";
+    private _db;
+    private readonly _path;
+    private readonly _wal;
+    private readonly _busyTimeout;
+    constructor(path: string, options?: {
+        wal?: boolean;
+        busyTimeout?: number;
+    });
+    get db(): NodeDatabaseSync;
+    open(): void;
+    close(): void;
+    run(sql: string, params?: unknown[]): void;
+    get(sql: string, params?: unknown[]): Row | undefined;
+    all(sql: string, params?: unknown[]): Row[];
+    prepare(sql: string): PreparedStatement;
+    introspectColumns(table: string): string[];
+    /** Mirror of SQLiteAdapter.addColumn — SQLite ALTER quirks are binding-agnostic. */
+    addColumn(table: string, column: string, typeSpec: string): void;
+    /**
+     * O(1) watch-loop change-probe — same composition as SQLiteAdapter, but
+     * `data_version` is read with a plain prepared statement because node:sqlite
+     * has no `.pragma(name, { simple: true })` scalar helper.
+     */
+    changeProbe(): string;
+    runAsync(sql: string, params?: unknown[]): Promise<void>;
+    getAsync(sql: string, params?: unknown[]): Promise<Row | undefined>;
+    allAsync(sql: string, params?: unknown[]): Promise<Row[]>;
+    introspectColumnsAsync(table: string): Promise<string[]>;
+    introspectAllColumns(tables: string[]): Promise<Map<string, Set<string>>>;
+    addColumnAsync(table: string, column: string, typeSpec: string): Promise<void>;
+    /** BEGIN/COMMIT around an awaited fn; ROLLBACK on throw. Mirror of SQLiteAdapter. */
+    withClient<T>(fn: (tx: TxClient) => Promise<T>): Promise<T>;
+}
+
 /**
  * Pluggable Postgres backend for Lattice.
  *
@@ -4898,6 +5056,724 @@ declare class PostgresAdapter implements StorageAdapter {
     private _registerPolyfills;
 }
 
+/**
+ * Connector SPI — the fetch/auth contract a connector implementation satisfies.
+ *
+ * A *connector* (e.g. the built-in Jira connector) handles authentication and
+ * data fetching for an external product (*toolkit*, e.g. `jira`), and exposes
+ * each external object type as a *connected data type* — a Lattice table whose
+ * rows are synced from the source.
+ *
+ * The SPI is deliberately small: establish a connection, stream normalized
+ * records for a model, and revoke. Everything Lattice-specific
+ * (schema, ACL, graph edges, teardown) is driven from the {@link ConnectedModelDef}
+ * descriptors and handled by the sync engine — a connector only fetches + maps.
+ */
+
+/**
+ * A foreign-key relation on a connected model, used to auto-build graph edges
+ * after a sync (via `extractEdgesFromColumn`) so connected rows are retrievable
+ * as relationship-aware context.
+ */
+interface ConnectedEdgeSpec {
+    /** FK column on this model's table. */
+    fkColumn: string;
+    /** The table the FK points to. */
+    dstTable: string;
+    /** Edge type label (e.g. `'in_project'`). */
+    type: string;
+}
+/**
+ * One model a toolkit exposes as a connected data type. Carries the full Lattice
+ * {@link TableDefinition} (with a `source` descriptor) plus the graph edges to
+ * derive after each sync.
+ */
+interface ConnectedModelDef {
+    /** Model key within the toolkit (e.g. `'issue'`). */
+    model: string;
+    /** Lattice table name (e.g. `'jira_issues'`). */
+    table: string;
+    /** Natural-key column — also the table's primary key, for idempotent upsert. */
+    naturalKey: string;
+    /** The table definition registered with `db.define()` (must set `source`). */
+    definition: TableDefinition;
+    /** FK relations to materialize as graph edges after sync. */
+    graphEdges?: ConnectedEdgeSpec[];
+    /** Embedded text columns, so the sync engine can refresh embeddings. */
+    embedded?: boolean;
+    /**
+     * Declares this model is fetched once *per parent row* rather than in one pass
+     * (e.g. comments fetched per issue). The sync engine queries the parent table's
+     * already-synced keys and calls {@link Connector.listChanges} with each as
+     * `parentKey`. Omit for models fetched in a single paged pass.
+     */
+    parent?: {
+        /** The parent connected table (must be synced earlier in the model order). */
+        table: string;
+        /** The parent's key column to iterate (its natural key / primary key). */
+        keyColumn: string;
+        /** The FK column on THIS table to stamp with each parent key during sync. */
+        childColumn: string;
+        /**
+         * Optional parent timestamp column (e.g. `'updated'`). When set, after the
+         * first sync only parents whose timestamp advanced since the connector's last
+         * sync are re-fetched — bounding an O(parents) per-parent crawl on a large
+         * source. (The pass is then incremental, so vanished children aren't pruned.)
+         */
+        incrementalColumn?: string;
+    };
+}
+/**
+ * A record fetched from the external source, normalized for upsert. `row` holds
+ * the column→value map for the Lattice table (the connector lineage columns are
+ * stamped by the sync engine, not here).
+ */
+interface ExternalRecord {
+    /** Natural-key value (the row's primary key). */
+    id: string;
+    /** Column→value map for the table row. */
+    row: Record<string, unknown>;
+}
+/**
+ * Sidebar/settings presentation metadata for one toolkit — the label and logo
+ * the GUI renders. Driven entirely by the connector so adding a connector needs
+ * no GUI code.
+ */
+interface ToolkitPresentation {
+    /** Human-readable name shown next to the logo (e.g. `'Jira'`). */
+    label: string;
+    /** Logo as a `data:` URI (e.g. `data:image/svg+xml;base64,…`), shown as an `<img src>`. */
+    icon?: string;
+}
+/**
+ * One credential input on a connector's connect form — METADATA describing the
+ * field, never a value. The GUI renders one input per entry; the generic connect
+ * handler reads the submitted values by `key`.
+ */
+interface CredentialField {
+    /** Body key the submitted value is sent under (e.g. `'token'`). */
+    key: string;
+    /** Field label shown to the user (e.g. `'API token'`). */
+    label: string;
+    /** Input type — `'password'` masks the value. */
+    type: 'text' | 'password';
+    /** Optional placeholder shown in the empty input. */
+    placeholder?: string;
+    /** Whether the value is required (default true at the route layer). */
+    required?: boolean;
+}
+/** Result of beginning an OAuth authorization for a member. */
+interface AuthorizeResult {
+    /** The URL the member must visit to grant access. */
+    redirectUrl: string;
+    /** Opaque handle to poll/finalize the pending connection. */
+    pendingId?: string;
+}
+/** Result of finalizing a connection after the member completes OAuth. */
+interface ConnectionResult {
+    /** The backend connected-account id, stored in the registry. */
+    connectionId: string;
+}
+/** Context for a sync fetch — the member's connection + identity. */
+interface ListChangesContext {
+    /** The connector backend's connected-account id. */
+    connectionId: string;
+    /** Per-member identity (the connector backend's user id). */
+    userId: string;
+    /** Cursor from a prior page, or null for a full pull. */
+    cursor?: string | null;
+    /** Parent row key for a per-parent model (e.g. an issue key when fetching its comments). */
+    parentKey?: string;
+}
+/**
+ * A connector implementation. Concrete connectors (e.g. the Jira connector)
+ * implement this; the sync engine and GUI program against it.
+ */
+interface Connector {
+    /** Connector id (e.g. `'jira'`). */
+    readonly connector: string;
+    /** The toolkits this connector can serve (e.g. `['jira']`). */
+    toolkits(): string[];
+    /** The connected-data-type models for a toolkit. */
+    models(toolkit: string): ConnectedModelDef[];
+    /** Sidebar/settings presentation (label + logo) for a toolkit this connector serves. */
+    presentation(toolkit: string): ToolkitPresentation;
+    /** Begin OAuth for a member + toolkit; returns a redirect URL. */
+    authorize(userId: string, toolkit: string): Promise<AuthorizeResult>;
+    /** Finalize the connection once the member has completed OAuth. */
+    completeAuth(userId: string, toolkit: string): Promise<ConnectionResult>;
+    /**
+     * Stream normalized records for a model, paginated and bounded. Implementations
+     * MUST page rather than load everything at once (bounded reads).
+     */
+    listChanges(toolkit: string, model: string, ctx: ListChangesContext): AsyncIterable<ExternalRecord>;
+    /** Revoke a connected account (teardown). */
+    disconnect(connectionId: string): Promise<void>;
+}
+/**
+ * A connector that connects via direct credentials the member pastes in — an API
+ * key, token, site URL, etc. — rather than an OAuth redirect. The GUI renders a
+ * form from {@link CredentialConnector.credentialFields} and calls
+ * {@link CredentialConnector.connect} with the collected values; the connector
+ * validates them against the source and stores them encrypted.
+ */
+interface CredentialConnector extends Connector {
+    /** The credential inputs the connect form must render (metadata only). */
+    credentialFields(): CredentialField[];
+    /**
+     * Validate the submitted credentials against the source and, on success, store
+     * them encrypted under a fresh connection id. Returns the connection id (the
+     * caller records it in the registry) and a validated display name for the UI.
+     * Throws loudly on invalid credentials — never returns a silent default.
+     */
+    connect(creds: Record<string, string>): Promise<{
+        connectionId: string;
+        displayName: string | null;
+    }>;
+    /** Optional URL to docs for obtaining the credentials (shown as a help link). */
+    helpUrl?(): string | undefined;
+}
+/**
+ * True when `c` is a {@link CredentialConnector} — i.e. it connects via direct
+ * credentials (both `connect` and `credentialFields` are functions). The route
+ * layer uses this to decide whether to serve the credential connect form.
+ */
+declare function isCredentialConnector(c: Connector): c is CredentialConnector;
+
+/**
+ * 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.
+ *
+ * Named `catalog.ts` (not `registry.ts`) to avoid confusion with the
+ * `__lattice_connectors` DB table managed in `registry.ts`: this is the in-memory
+ * set of connector *implementations*; that is the per-member *connection* records.
+ */
+
+/**
+ * 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.
+ */
+declare function builtinConnectors(): Connector[];
+
+/**
+ * Connector registry — the set of external sources a workspace has connected.
+ *
+ * One internal `__lattice_connectors` table (GUI-hidden by the `__lattice_`
+ * prefix) records each connector instance: which implementation backs it
+ * (`connector`, e.g. `'jira'`), which product (`toolkit`, e.g. `'jira'`),
+ * the opaque per-member connection handle (`connectionRef`), who connected
+ * it, and its sync state. No secret material is stored here — the connector's
+ * credentials (e.g. a SaaS API token) live in the machine-local encrypted
+ * credential store, keyed by the connection handle.
+ *
+ * On a cloud workspace the table is RLS-scoped private-to-owner (see the ACL
+ * wiring), so each member sees and manages only their own connectors.
+ *
+ * The table is created on demand (idempotent `CREATE TABLE IF NOT EXISTS`), so a
+ * library consumer that never touches connectors pays nothing.
+ */
+
+declare const CONNECTORS_TABLE = "__lattice_connectors";
+/** Lifecycle state of a connector instance. */
+type ConnectorStatus = 'connected' | 'error' | 'disconnected';
+/** A row in the connector registry. */
+interface ConnectorRecord {
+    id: string;
+    /** Connector implementation, e.g. `'jira'`. */
+    connector: string;
+    /** External product/toolkit, e.g. `'jira'`. */
+    toolkit: string;
+    /** Human-friendly label shown in the GUI. */
+    displayName: string | null;
+    /** Opaque per-member connection handle (the key for the connection's stored credentials). */
+    connectionRef: string | null;
+    /** Identity that connected this instance (member role / user id). */
+    connectedBy: string | null;
+    status: ConnectorStatus;
+    /** ISO timestamp of the last successful sync, or null if never synced. */
+    lastSyncAt: string | null;
+    /** Last sync error message (cleared on success), or null. */
+    lastError: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Create the registry table if it doesn't exist (idempotent; both dialects). */
+declare function ensureConnectorRegistry(db: Lattice): Promise<void>;
+interface CreateConnectorInput {
+    connector: string;
+    toolkit: string;
+    displayName?: string;
+    connectionRef?: string;
+    connectedBy?: string;
+}
+/** Insert a connector instance and return its id. */
+declare function createConnector(db: Lattice, input: CreateConnectorInput): Promise<string>;
+/** Fetch one connector by id, or null. */
+declare function getConnector(db: Lattice, id: string): Promise<ConnectorRecord | null>;
+/**
+ * Fetch the connector for a toolkit (optionally scoped to a connecting identity).
+ * Returns the most recently created match, or null.
+ */
+declare function getConnectorByToolkit(db: Lattice, toolkit: string, connectedBy?: string): Promise<ConnectorRecord | null>;
+/**
+ * List connectors. Pass `connectedBy` to scope to one identity — an APP-LAYER
+ * fail-closed filter that does not rely on RLS (the app/owner connection is
+ * BYPASSRLS, so RLS would not filter its own reads). Callers serving a specific
+ * member MUST pass it so one member can't see another's connectors.
+ */
+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>;
+/** Record a sync outcome: success stamps `last_sync_at` + clears the error. */
+declare function recordSync(db: Lattice, id: string, outcome: {
+    ok: true;
+    at: string;
+} | {
+    ok: false;
+    error: string;
+}): Promise<void>;
+/**
+ * The per-member identity to key connectors on. On a cloud (Postgres) this is the
+ * member's `session_user` (the scoped login role the RLS ownership model keys on),
+ * so the connector's per-member partition and the row-ownership stamp agree. On
+ * SQLite / non-cloud it's the caller's `fallback` (the machine-local identity).
+ */
+declare function resolveConnectorIdentity(db: Lattice, fallback: string): Promise<string>;
+/** Set a connector's lifecycle status (e.g. `'disconnected'` on teardown). */
+declare function setConnectorStatus(db: Lattice, id: string, status: ConnectorStatus): Promise<void>;
+/** Hard-delete a connector registry row (used by a full teardown). */
+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.
+ *
+ * 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.
+ */
+
+/** 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. */
+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;
+    }>;
+}
+/**
+ * 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.
+ */
+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;
+    /**
+     * 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.
+     */
+    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<{
+        connectionId: string;
+        displayName: string | null;
+    }>;
+    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;
+}
+
+/**
+ * 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.
+ */
+
+/** All six Jira connected models, in dependency order (parents before children). */
+declare const JIRA_MODELS: 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.
+ */
+declare function defineJiraTables(db: Lattice): Promise<void>;
+
+/**
+ * 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 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.
+ */
+
+/** 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;
+}
+/** 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";
+    /**
+     * @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).
+     */
+    constructor(clientFactory?: (creds: TrelloCreds) => Promise<TrelloClient>, credsLoader?: (connectionId: string) => TrelloCreds | null);
+    toolkits(): string[];
+    models(toolkit: string): ConnectedModelDef[];
+    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.
+     */
+    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.
+     */
+    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.
+     */
+    private pageBefore;
+}
+
+/**
+ * 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.
+ *
+ * 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 eleven Trello connected models, in dependency order (parents before children). */
+declare const TRELLO_MODELS: ConnectedModelDef[];
+/**
+ * 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.
+ */
+declare function defineTrelloTables(db: Lattice): Promise<void>;
+
+/**
+ * Connector sync engine.
+ *
+ * Pulls each connected model's records from the source (paginated, bounded),
+ * upserts them idempotently on the natural key (stamping connector lineage),
+ * soft-deletes rows that vanished from the source, and derives graph edges so
+ * the data is retrievable as relationship-aware context. Driven entirely by the
+ * connector's {@link ConnectedModelDef}s — no per-product code here.
+ *
+ * Failure policy: a sync touches an external system, so any error is recorded on
+ * the connector and re-thrown (surfaced loudly, never swallowed).
+ *
+ * Freshness: `syncIfStale` / `syncStaleConnectors` implement "sync on connect,
+ * on load if older than an hour, and on manual refresh" without a scheduler.
+ */
+
+/** Default staleness window — re-sync on load when older than this. */
+declare const DEFAULT_STALE_MS = 3600000;
+interface SyncConnectorResult {
+    connectorId: string;
+    /** Upserted row count per table. */
+    upserted: Record<string, number>;
+    /** Soft-deleted (vanished) row count per table. */
+    softDeleted: Record<string, number>;
+    /** Total graph edges derived. */
+    edges: number;
+    /** ISO timestamp stamped on this sync. */
+    syncedAt: string;
+}
+interface SyncConnectorOptions {
+    /** Soft-delete rows absent from the source this sync. Default true. */
+    pruneVanished?: boolean;
+}
+/** Run a full sync for one connector instance. */
+declare function syncConnector(db: Lattice, connector: Connector, connectorId: string, opts?: SyncConnectorOptions): Promise<SyncConnectorResult>;
+/**
+ * Collect all natural keys for a connector's rows in a table, paged + projected
+ * to the single key column (bounded reads — never a full-row table scan). Shared
+ * by the sync prune pass and the disconnect teardown.
+ */
+declare function collectConnectorKeys(db: Lattice, table: string, keyColumn: string, connectorId: string): Promise<string[]>;
+/** Sync only if the connector hasn't synced within `maxAgeMs`. Returns null if fresh. */
+declare function syncIfStale(db: Lattice, connector: Connector, connectorId: string, maxAgeMs?: number): Promise<SyncConnectorResult | null>;
+/** Outcome of a batch stale-sync: the connectors that synced + the ones that failed. */
+interface SyncStaleResult {
+    synced: SyncConnectorResult[];
+    failed: {
+        connectorId: string;
+        error: string;
+    }[];
+}
+/**
+ * Sync every stale connector served by this connector implementation. The GUI
+ * calls this on load so connected data refreshes hourly without a scheduler.
+ *
+ * Scope to the connecting member with `connectedBy` — each member syncs only
+ * their OWN connectors (their session stamps row ownership; an owner must not
+ * sync members' connectors as themselves). Per-connector failures are ISOLATED:
+ * one broken connection records its error and is reported in `failed`, but never
+ * blocks the refresh of the member's other connectors.
+ */
+declare function syncStaleConnectors(db: Lattice, connector: Connector, maxAgeMs?: number, connectedBy?: string): Promise<SyncStaleResult>;
+
+/**
+ * Connector teardown — disconnecting a connector makes its data "no longer
+ * available."
+ *
+ * Soft-deletes every row the connector ingested (children before parents), prunes
+ * the rendered context files for them, marks the connector disconnected (or
+ * removes it in hard mode), and revokes the backend connection. Soft-deleted rows
+ * drop out of the rendered context, full-text search, and the GUI's listings (all
+ * of which filter `deleted_at IS NULL`), and their graph edges are removed — so
+ * the data is no longer available to the agent, while staying physically present
+ * and restorable. On cloud, the per-viewer render prune removes each member's
+ * context files.
+ */
+
+interface DisconnectOptions {
+    /**
+     * `'soft'` (default) keeps the registry row as `disconnected` (reconnectable);
+     * `'hard'` also removes the registry row. Ingested rows are soft-deleted in
+     * both modes (Lattice never hard-deletes rows).
+     */
+    mode?: 'soft' | 'hard';
+    /** When set, re-render to prune context files for the removed rows. */
+    outputDir?: string;
+}
+interface DisconnectResult {
+    connectorId: string;
+    mode: 'soft' | 'hard';
+    /** Soft-deleted row count per table. */
+    softDeleted: Record<string, number>;
+}
+/** Disconnect a connector and tear down everything it ingested. */
+declare function disconnectConnector(db: Lattice, connector: Connector, connectorId: string, opts?: DisconnectOptions): Promise<DisconnectResult>;
+
+/**
+ * Connector ACL wiring (cloud Postgres).
+ *
+ * On a cloud workspace, connected data is scoped per connecting member by the
+ * same Row-Level Security that protects every other table: the registry and each
+ * connected table get RLS enabled, the insert trigger stamps the connecting
+ * member as owner, and `lattice_row_visible` keeps a member's rows private to
+ * them — unless a connected type is marked shared (`everyone`), in which case its
+ * rows default to visible to the whole team.
+ *
+ * Because enabling RLS / DDL requires owner privilege, this is an OWNER setup
+ * step (it no-ops for a non-owner, a non-cloud workspace, or SQLite). The owner
+ * defines the connected tables and calls this once; members then sync their own
+ * rows into the shared tables, born private to each member.
+ *
+ * Derived enrichment over connected rows inherits the connector data's
+ * visibility automatically: write it through `db.observe(..., { changeKind:
+ * 'derived', sourceRef: [connectedRowId] })`, and the existing source-gated fold
+ * (`foldEntity` / `observationVisible`) hides it from a viewer who can't see the
+ * source. No connector-specific code is needed for that — use the substrate.
+ */
+
+/**
+ * Enable per-member RLS on the connector registry and a toolkit's connected
+ * tables, and apply each connected type's default visibility. Owner-only; a
+ * no-op on SQLite, a non-cloud Postgres, or for a non-owner role. The connected
+ * tables must already exist (define them first).
+ */
+declare function enableConnectorRls(db: Lattice, connector: Connector, toolkit: string): Promise<void>;
+/**
+ * Define + secure EVERY toolkit's connected tables (and the registry) for a
+ * connector. Run by the owner on workspace open so connected tables created in a
+ * member's session are RLS-protected even though the owner never connected — the
+ * durable fix for "a member's lazily-registered connected table is born without
+ * RLS." Owner-only; a no-op on SQLite / non-cloud / non-owner.
+ */
+declare function secureConnectorTables(db: Lattice, connector: Connector): Promise<void>;
+
 /**
  * Durable retry for transient database failures.
  *
@@ -5278,9 +6154,15 @@ interface UserPreferences {
      * Preferred speech-to-text provider for the assistant's voice notes. This is
      * a USER preference, not a workspace secret — it lives here (machine-local) so
      * it persists across workspaces and never appears in any workspace's `secrets`
-     * object. `'auto'` infers from whichever provider key is configured.
+     * object.
+     *   `'local'`      — on-device, in-browser speech model. The keyless default:
+     *                    no API key, no config, audio never leaves the machine.
+     *   `'openai'` /   — cloud providers (fallback when a key IS configured).
+     *   `'elevenlabs'`
+     *   `'auto'`       — infer from whichever cloud provider key is configured;
+     *                    legacy "off" sentinel kept for back-compat.
      */
-    voice_provider: 'auto' | 'openai' | 'elevenlabs';
+    voice_provider: 'local' | 'auto' | 'openai' | 'elevenlabs';
     /**
      * Inference aggressiveness (0 = conservative … 1 = aggressive). Drives the
      * assistant's sampling temperature and how liberally ingest links/extracts.
@@ -6684,6 +7566,16 @@ interface StartGuiServerOptions {
      * ⇒ the version chip stays hidden.
      */
     version?: string;
+    /**
+     * Absolute path to the built `dist/gui-assets/` directory (the on-device voice
+     * worker + ONNX-Runtime WASM), served read-only at `GET /gui-assets/*`. Passed
+     * by `cli.ts` (resolved against the package via `import.meta.url`, like
+     * `version`) because server.ts is bundled to both CJS and ESM — reading the
+     * path via `import.meta.url` here would break the CJS bundle. Omitted ⇒ a
+     * best-effort default (sibling of the running CLI bundle, else `<cwd>/dist/
+     * gui-assets`), so source/dev/test runs still serve the assets when present.
+     */
+    guiAssetsDir?: string;
     /**
      * Realtime backstop liveness-poll interval (ms) for the RealtimeBroker. A
      * managed-Postgres proxy (e.g. AWS RDS Proxy) can silently drop the LISTEN
@@ -6707,6 +7599,13 @@ interface StartGuiServerOptions {
      * it overrides `selfUpdate`'s default factory.
      */
     updateServiceFactory?: (emit: (type: string, data: unknown) => void) => UpdateService;
+    /**
+     * 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
+     * to `GET /api/desktop/open` which calls this. Omitted for the web/CLI GUI —
+     * the route then 404s, so a browser-served GUI can never trigger an OS open.
+     */
+    desktopOpenExternal?: (url: string) => void;
 }
 interface GuiServerHandle {
     server: Server;
@@ -7117,4 +8016,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 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, 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 CountOptions, type CrawlOptions, type CrawlResult, type CustomSignal, type CustomSource, DEFAULT_ENTRY_TYPES, DEFAULT_MAX_NODES, DEFAULT_TYPE_ALIASES, type DetectedView, type DiagnoseOptions, 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 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, type ImportMode, type ImportProgress, InMemorySourceKeyStore, InMemoryStateStore, type InferredColumn, type InferredDimension, type InferredEntity, type InferredLinkage, type InferredType, type InitOptions, 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 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 SyncResult, TRUST_COLUMNS, type TableDefinition, type TableHealth, type TablePolicy, type TemplateRenderSpec, type TextChunk, 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 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, canManageRoles, checkSlos, chunkText, classifyLinks, cloudRlsInstalled, computeColumns, computedColumnDdl, computedColumnOrder, concatRowText, configDir, contentHash, cosineSimilarity, crawlUrl, createReadOnlyHeader, createS3Store, createSQLiteStateStore, decrypt, dedupeAndDetectViews, defaultWorkspaceYaml, deleteDbCredential, deleteToken, deriveCanonicalContexts, deriveKey, describeImage, describePdf, detectAsOf, detectAsOfCandidates, detectAsOfColumns, detectRetrievalRegressions, diagnoseRetrieval, discoverCloudTables, dropVectorIndex, enableAudienceView, enableChangelogRls, enableRlsForTable, encrypt, enrichKnowledge, ensureCheckpointTable, ensureEdgesTable, ensureEmbeddingsTable, ensureFtsIndex, ensureLatticeRoot, entityFileNames, estimateTokens, evaluateRetrieval, excelToRecords, extractEdgesFromColumn, extractObjects, filePresignSql, findLatticeRoot, fixSchemaConflicts, foldEntity, formatHealthReport, frontmatter, ftsTableName, fullTextSearch, generateEntryId, generateMemberPassword, generateWriteEntryId, getActiveWorkspace, getCloudSetting, getDbCredential, getMigrationCheckpoint, getOrCreateMasterKey, getTablePolicy, getWorkspace, grantPresignerToMemberGroup, graphAdjacencyBoost, hasFilePresigner, hasFtsIndex, hasVectorIndex, hashFile, hybridSearch, importLegacyUserConfig, inferFieldType, inferSchema, installCloudRls, installCloudSettings, installFilePresigner, isEncrypted, isNativeEntity, isPostgresUrl, isPrivateIp, isRetryableDbError, isRowAudience, latencyStats, listDbCredentials, listMigrationCheckpoints, listNativeBindings, listTokens, listWorkspaces, loadColumnPolicy, 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, referenceLocalFile, referenceUrl, refreshEmbeddings, regenerateAudienceViewFromDb, registerNativeEntities, registryPath, removeEdge, removeEmbedding, renameEntities, resolveActiveS3Config, resolveLatticeRoot, resolveProvenanceFields, resolveSource, resolveTrustDefault, resolveWorkspacePaths, resumeMigration, revertMigration, revokeMemberRole, rewardBoost, rollupColumnDdl, rootConfigDir, s3Key, saveDbCredential, saveDbCredentialForTeam, sealUnderSource, searchByEmbedding, searchVectorIndex, secureCloud, seedColumnPolicyFromYaml, semanticChunker, setActiveWorkspace, setCloudS3Secret, setCloudSetting, setColumnAudience, setRowVisibility, setTableDefaultVisibility, setTableNeverShare, shredSource, slugify, sourceRecords, startGuiServer, storeEmbedding, summarizeText, tableNeedsAudienceView, toSafeDirName, traverse, truncate, validateEntryId, vectorIndexAvailable, vectorIndexName, withRetry, workspaceBlobsDir, workspaceConfigPath, workspaceContextDir, workspaceDataDir, workspaceDbPath, workspaceDir, workspacesDir, writeIdentity, writeManifest, writePreferences, writeRegistry, writeToken };
+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 };