@jarenjs/db 0.34.0

package/dist/types/algebra.d.ts

@@ -0,0 +1,133 @@
+/**
+ * @file The Plan algebra: the dialect-neutral middle stage between the
+ * engine's AST and a dialect's SQL. A plan is a plain JSON value —
+ * inspectable, golden-testable without a database — and it carries NO
+ * SQL text: every string in a plan is a member name, a type tag, an
+ * external name or a reason sentence, never a fragment of any query
+ * language. `assertNoSqlText` is the tripwire the tests run over every
+ * golden.
+ *
+ * One plan shape covers this version: a guarded selection over ONE
+ * collection with optional ordering, window, aggregate and a
+ * whole-document projection. Constructs beyond it are residuals by
+ * design (see ARCHITECTURE.md's deliberate-residual table).
+ */
+/** The plan format version, carried on every plan. */
+export declare const PLAN_VERSION = 1;
+export type PlanRef = {
+    segments: ({
+        name: string;
+    } | {
+        index: number;
+    })[];
+    type: string;
+    column: string | null;
+};
+export type PlanOperand = {
+    lit: unknown;
+} | {
+    ext: string;
+};
+export type PlanPredicate = ({
+    p: 'and' | 'or';
+    items: PlanPredicate[];
+} | {
+    p: 'not';
+    item: PlanPredicate;
+} | {
+    p: 'cmp';
+    op: 'eq' | 'ne' | 'lt' | 'le' | 'gt' | 'ge';
+    ref: PlanRef;
+    operand: PlanOperand;
+} | {
+    p: 'typeIs';
+    ref: PlanRef;
+    types: string[];
+    positive: boolean;
+} | {
+    p: 'strop';
+    kind: 'starts' | 'ends' | 'contains';
+    ref: PlanRef;
+    operand: PlanOperand;
+} | {
+    p: 'const';
+    value: boolean;
+} | {
+    p: 'udf';
+    name: string;
+    key: string;
+});
+export type PlanOrderTerm = {
+    ref: PlanRef;
+    desc: boolean;
+    emptyGreatest: boolean;
+};
+export type Plan = {
+    planVersion: number;
+    alg: 'select';
+    collection: string;
+    filter: PlanPredicate | null;
+    order: PlanOrderTerm[] | null;
+    window: {
+        offset: number;
+        limit: number | null;
+    } | null;
+    aggregate: {
+        fn: 'count' | 'sum' | 'avg' | 'min' | 'max';
+        ref: PlanRef | null;
+    } | null;
+    project: 'document';
+};
+/**
+ * @typedef {{ segments: ({ name: string } | { index: number })[],
+ *   type: string, column: string | null }} PlanRef
+ *   A typed reference into the stored document: `type` is the
+ *   schema-declared type or `'unknown'`; `column` is the generated
+ *   column name when the collection indexes this path.
+ *
+ * @typedef {{ lit: unknown } | { ext: string }} PlanOperand
+ *
+ * @typedef {(
+ *   { p: 'and' | 'or', items: PlanPredicate[] } |
+ *   { p: 'not', item: PlanPredicate } |
+ *   { p: 'cmp', op: 'eq' | 'ne' | 'lt' | 'le' | 'gt' | 'ge',
+ *     ref: PlanRef, operand: PlanOperand } |
+ *   { p: 'typeIs', ref: PlanRef, types: string[], positive: boolean } |
+ *   { p: 'strop', kind: 'starts' | 'ends' | 'contains',
+ *     ref: PlanRef, operand: PlanOperand } |
+ *   { p: 'const', value: boolean } |
+ *   { p: 'udf', name: string, key: string }
+ * )} PlanPredicate
+ *
+ * @typedef {{ ref: PlanRef, desc: boolean, emptyGreatest: boolean }} PlanOrderTerm
+ *
+ * @typedef {{
+ *   planVersion: number,
+ *   alg: 'select',
+ *   collection: string,
+ *   filter: PlanPredicate | null,
+ *   order: PlanOrderTerm[] | null,
+ *   window: { offset: number, limit: number | null } | null,
+ *   aggregate: { fn: 'count' | 'sum' | 'avg' | 'min' | 'max',
+ *     ref: PlanRef | null } | null,
+ *   project: 'document',
+ * }} Plan
+ */
+/**
+ * A fresh select plan over one collection.
+ * @param {string} collection
+ * @returns {Plan}
+ */
+export declare function selectPlan(collection: string): Plan;
+/**
+ * Conjoin a predicate onto a plan's filter.
+ * @param {PlanPredicate | null} filter
+ * @param {PlanPredicate} predicate
+ * @returns {PlanPredicate}
+ */
+export declare function conjoin(filter: PlanPredicate | null, predicate: PlanPredicate): PlanPredicate;
+/**
+ * Throw when a plan value carries anything that smells like SQL.
+ * @param {unknown} plan
+ */
+export declare function assertNoSqlText(plan: unknown): void;

package/dist/types/app.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @file The app binding for live queries (LIVE-FORMAT §10): GENERATED
+ * documents plus a handler factory — the `fsmToApp` precedent. The db
+ * package never imports `@jarenjs/app`; the app document declares a
+ * subscription (`APP-FORMAT §5.3`) whose registered handler is
+ * `createLiveSubscription(store)`, and a two-line action whose whole
+ * body is `{ patch: '$payload' }` — the handler prefixes every op
+ * with the declared state path, so the app loop applies live patches
+ * with the machinery it already has.
+ */
+/**
+ * Prefix every op path in a live patch with the state slot.
+ * @param {any[]} patch
+ * @param {string} statePath - JSON Pointer to the slot holding the
+ *   live result document
+ */
+export declare function prefixLivePatch(patch: any[], statePath: string): any[];
+/**
+ * The generated documents (§10): a subscription entry and the
+ * patch-forwarding action, both plain data for the app document.
+ * @param {{ run?: string, action?: string, statePath: string,
+ *   collection?: string, query: any, externals?: any, mode?: string,
+ *   when?: any }} options
+ * @returns {{ subscription: any, actions: any }}
+ */
+export declare function liveAppBinding(options: {
+    run?: string;
+    action?: string;
+    statePath: string;
+    collection?: string;
+    query: any;
+    externals?: any;
+    mode?: string;
+    when?: any;
+}): {
+    subscription: any;
+    actions: any;
+};
+/**
+ * The subscription handler factory: registers the live query when the
+ * subscription starts, dispatches ONE initializing patch (a `replace`
+ * of the whole slot), forwards each emission prefixed, and closes on
+ * cleanup. An emission error surfaces as a dispatch of
+ * `<action>/error` so the app can render it — silence is not an
+ * option the format allows.
+ * @param {any} store - an open store with capture
+ * @returns {(props: any, dispatch: Function) => Function}
+ */
+export declare function createLiveSubscription(store: any): (props: any, dispatch: Function) => Function;

package/dist/types/capture.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @file Change capture (D13): committed writes become an observable,
+ * ordered stream of RFC 6902 patches — derived from SQLite's own
+ * session changesets where the binding has them, from a write-path
+ * journal where it does not (`bun:sqlite` has no `createSession`), or
+ * off entirely. One diff format then runs end to end: store → patch →
+ * live query → patch → O(k) render.
+ *
+ * The pointer contract (LIVE-FORMAT §2): `/<table>/<key>/<path…>`,
+ * every token escaped per RFC 6901. A single key renders as its
+ * scalar text (integers in decimal); a composite key renders as the
+ * JSON text of its parts array. Join-table rows are tiny documents
+ * under the join table's name — membership changes are part of the
+ * stream, not a blind spot.
+ *
+ * Session facts this file is built on (probed, 3.51.2):
+ * - a changeset carries ONE NET OP PER ROW (insert+update coalesce;
+ *   insert+delete vanish; a no-op update is absent), and within-table
+ *   order is NOT statement order — every row op targets a distinct
+ *   pointer, so application order across rows cannot matter;
+ * - `ROLLBACK TO` a savepoint removes the undone rows from the
+ *   session (pinned by test — the classic caveat does NOT hold here);
+ * - a rolled-back transaction yields an empty changeset;
+ * - virtual generated columns are invisible;
+ * - an UPDATE's old record carries the primary key and the CHANGED
+ *   columns only — which is exactly enough for property-level ops,
+ *   and why the doc column's old/new blobs make a minimal nested
+ *   diff possible (`SELECT json(?)` turns JSONB back into text).
+ */
+/** The persisted change log (LIVE-FORMAT §5). */
+export declare const CHANGES_TABLE = "_jaren_changes";
+export declare const DEFAULT_RETENTION = 1000;
+/**
+ * Decode a binary changeset into row operations.
+ * @param {Uint8Array} bytes
+ * @returns {{ table: string, pk: boolean[], op: 'insert'|'update'|'delete',
+ *   indirect: boolean, oldValues: any[] | null, newValues: any[] | null }[]}
+ */
+export declare function parseChangeset(bytes: Uint8Array): {
+    table: string;
+    pk: boolean[];
+    op: 'insert' | 'update' | 'delete';
+    indirect: boolean;
+    oldValues: any[] | null;
+    newValues: any[] | null;
+}[];
+/**
+ * The key token (LIVE-FORMAT §2): a single key is its scalar text;
+ * a composite key is the JSON text of its parts array.
+ * @param {any[]} parts
+ * @returns {string}
+ */
+export declare function keyToken(parts: any[]): string;
+export type TableShape = {
+    kind: 'collection' | 'entity' | 'join';
+    columns: {
+        name: string;
+        role: 'key' | 'doc' | 'scalar' | 'fk' | 'epoch';
+        storage?: string;
+    }[];
+    keyIndexes: number[];
+    docIndex: number;
+};
+/**
+ * Translate parsed row operations into RFC 6902 ops, resolving JSONB
+ * blobs through the connection (`SELECT json(?)`).
+ * @param {any} connection
+ * @param {Map<string, TableShape>} shapes
+ * @param {any[]} operations
+ * @returns {any} value-or-promise of RFC 6902 ops
+ */
+export declare function translateOperations(connection: any, shapes: Map<string, TableShape>, operations: any[]): any;
+/**
+ * @param {{ connection: any, shapes: Map<string, TableShape>,
+ *   mode: 'session' | 'journal',
+ *   log: boolean, retention: number }} options
+ * @returns {any}
+ */
+export declare function createCaptureEngine(options: {
+    connection: any;
+    shapes: Map<string, TableShape>;
+    mode: 'session' | 'journal';
+    log: boolean;
+    retention: number;
+}): any;

package/dist/types/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/dag-job.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @file The composition (JOBS-FORMAT §7): a persisted `@jarenjs/flow`
+ * DAG run wired to a queue job. THE FLOW ENGINE IS INJECTED, NEVER
+ * IMPORTED — the shared invariant forbids `@jarenjs/db` importing
+ * `@jarenjs/flow`, so `compileDag` arrives as a capability (the D10
+ * shape applied to flow) and a test asserts the manifest and import
+ * graph name flow nowhere.
+ *
+ * Each kind's document compiles ONCE against a delegating checkpoint
+ * store; per claimed job, the delegate binds the engine's guarded
+ * per-job store (`checkpointsFor`) — `save` refuses once the lease is
+ * lost and `complete` records the DAG result, marks the job done and
+ * prunes the checkpoint rows in ONE transaction, so a failure leaves
+ * neither and a crash resumes instead of restarting.
+ */
+/**
+ * Build a worker whose handlers run checkpointed DAG documents.
+ * @param {any} store - an open store with `{ jobs: true }`
+ * @param {{ compileDag: Function,
+ *   documents: Record<string, any>,
+ *   tasks?: Record<string, Function>,
+ *   concurrency?: number, pollInterval?: number, leaseMs?: number,
+ *   owner?: string, backoffBase?: number, backoffCap?: number }} options
+ * @returns {{ start: () => any, stop: () => Promise<void>, stats: () => any }}
+ */
+export declare function createDagJobRunner(store: any, options: {
+    compileDag: Function;
+    documents: Record<string, any>;
+    tasks?: Record<string, Function>;
+    concurrency?: number;
+    pollInterval?: number;
+    leaseMs?: number;
+    owner?: string;
+    backoffBase?: number;
+    backoffCap?: number;
+}): {
+    start: () => any;
+    stop: () => Promise<void>;
+    stats: () => any;
+};

package/dist/types/ddl.d.ts

@@ -0,0 +1,170 @@
+/**
+ * @file DDL planning: a normalized collection becomes one physical
+ * table — a key column, a JSON document column, a virtual generated
+ * column per indexed path, and the declared indexes — with every byte
+ * of SQL rendered by the dialect.
+ *
+ * Index paths are JSONPath expressions analyzed through the engine's
+ * PUBLISHED AST (`analyzeQuery`): a path is indexable exactly when the
+ * analysis says it is singular and every segment is a plain member or
+ * index selection. That reuses the one grammar authority instead of
+ * re-parsing, and it fails loudly (`JD0004`) on everything else —
+ * wildcards, slices, filters, descendants, functions — rather than
+ * silently indexing the wrong thing.
+ */
+/** The fixed physical column names of the 0.1 mapping. */
+export declare const KEY_COLUMN = "key";
+export declare const DOC_COLUMN = "doc";
+/**
+ * Analyze one index path expression down to typed segments.
+ * @param {string} expression - A JSONPath expression (`$.email`)
+ * @param {string} docPath - Model-document pointer for diagnostics
+ * @returns {{ segments: import('./dialect.js').JsonPathSegment[],
+ *   canonical: string }}
+ */
+export declare function compileIndexPath(expression: string, docPath: string): {
+    segments: import('./dialect.js').JsonPathSegment[];
+    canonical: string;
+};
+/**
+ * The declared schema type at a segment path, walked structurally
+ * through `properties` / `items` / `prefixItems`. The collection's
+ * schema is the type source — that is why the physical mapping needs
+ * no engine-side inference.
+ * @param {any} schema
+ * @param {import('./dialect.js').JsonPathSegment[]} segments
+ * @returns {string | undefined}
+ */
+export declare function schemaTypeAt(schema: any, segments: import('./dialect.js').JsonPathSegment[]): string | undefined;
+/**
+ * Plan one collection's physical shape: the DDL statements to create
+ * it and the structural facts an existing table must match (the
+ * `JD0002` comparison set).
+ * @param {string} name - The collection name (also the table name)
+ * @param {{ schema: any, keySegments: { name: string }[] | null,
+ *   identity: string, indexes: { name: string, paths: string[],
+ *   unique: boolean, docPath: string }[] }} collection - normalized
+ * @param {any} dialect
+ * @returns {{
+ *   table: string, keyColumn: string, docColumn: string,
+ *   keyType: string,
+ *   generated: { name: string, type: string, pathText: string,
+ *     canonical: string }[],
+ *   columnByCanonical: Map<string, string>,
+ *   createSql: string[],
+ *   expected: { columns: { name: string, type: string,
+ *     generated: boolean }[], indexes: { name: string, unique: boolean,
+ *     columns: string[] }[] },
+ * }}
+ */
+export declare function planCollection(name: string, collection: {
+    schema: any;
+    keySegments: {
+        name: string;
+    }[] | null;
+    identity: string;
+    indexes: {
+        name: string;
+        paths: string[];
+        unique: boolean;
+        docPath: string;
+    }[];
+}, dialect: any): {
+    table: string;
+    keyColumn: string;
+    docColumn: string;
+    keyType: string;
+    generated: {
+        name: string;
+        type: string;
+        pathText: string;
+        canonical: string;
+    }[];
+    columnByCanonical: Map<string, string>;
+    createSql: string[];
+    expected: {
+        columns: {
+            name: string;
+            type: string;
+            generated: boolean;
+        }[];
+        indexes: {
+            name: string;
+            unique: boolean;
+            columns: string[];
+        }[];
+    };
+};
+/**
+ * Normalize a stored `CREATE` statement for comparison: collapse runs of
+ * whitespace, drop whitespace around punctuation, and strip the
+ * `IF NOT EXISTS` SQLite does not keep. What survives is every token that
+ * carries meaning, so two statements compare equal exactly when they
+ * declare the same physical object.
+ * @param {string} sql
+ * @returns {string}
+ */
+export declare function normalizeDeclaredSql(sql: string): string;
+/**
+ * A comparable form of one `CREATE` statement.
+ *
+ * For a TABLE the column definitions compare as a SET, because
+ * `ALTER TABLE … ADD COLUMN` can only append — so a migrated table and a
+ * freshly built one legitimately differ in column order, and this store
+ * never reads a column positionally. Everything else is exact: each
+ * column's full definition (type, `PRIMARY KEY`, `NOT NULL`, `DEFAULT`,
+ * `CHECK`, `GENERATED … AS`, `REFERENCES … ON DELETE …`), the table
+ * constraints, and the trailing table options (`STRICT`,
+ * `WITHOUT ROWID`).
+ *
+ * For an INDEX the text compares whole, because an index IS its order —
+ * `(a,b)` and `(b,a)` serve different lookups — as are its partial
+ * predicate and each term's collation and direction.
+ * @param {string} sql
+ * @returns {string}
+ */
+export declare function comparableDeclaredSql(sql: string): string;
+/**
+ * Verify an existing table against the planned shape; any difference
+ * is `JD0002` and nothing is altered. Shared by the store's open path
+ * and the migration engine's shadow validation.
+ * @param {any} connection
+ * @param {any} plan
+ * @param {string} collection
+ * @param {string} docPath
+ * @returns {any} value-or-promise
+ */
+export declare function verifyShape(connection: any, plan: any, collection: string, docPath: string): any;
+/**
+ * Plan one ENTITY's physical shape from the mapping data
+ * `explainMapping` derived: the relational table (typed columns,
+ * checks, foreign keys, the JSONB document column), its indexes, and
+ * the structural facts an existing table must match. One verify path
+ * serves both document kinds.
+ * @param {string} name
+ * @param {any} entityMapping - `explainMapping(model).entities[name]`
+ * @param {any} entities - the full `explainMapping` result (key types
+ *   come from the referenced entity's columns)
+ * @param {any} dialect
+ * @returns {{ table: string, createSql: string[], expected: any,
+ *   columnNames: Set<string> }}
+ */
+export declare function planEntity(name: string, entityMapping: any, entities: any, dialect: any): {
+    table: string;
+    createSql: string[];
+    expected: any;
+    columnNames: Set<string>;
+};
+/**
+ * Plan a many-to-many join table.
+ * @param {string} tableName
+ * @param {any} join - `explainMapping(model).joinTables[tableName]`
+ * @param {any} entities - the full mapping
+ * @param {any} dialect
+ * @returns {{ table: string, createSql: string[], expected: any }}
+ */
+export declare function planJoinTable(tableName: string, join: any, entities: any, dialect: any): {
+    table: string;
+    createSql: string[];
+    expected: any;
+};

package/dist/types/dialect.d.ts

@@ -0,0 +1,130 @@
+/**
+ * @file The dialect seam: the ONLY place SQL text is produced. A
+ * dialect is data plus a small emitter — a spelling spec (how to quote
+ * an identifier, reference a parameter, extract a JSON member, open a
+ * savepoint) composed by {@link createDialect} into the DDL and DML
+ * statement builders the store consumes. Nothing outside a dialect
+ * concatenates SQL; that costs one indirection now, and without it a
+ * second backend is a rewrite.
+ *
+ * Deliberately NOT in the dialect, because they are behavioural rather
+ * than syntactic: whether functions can be registered per connection,
+ * whether change capture exists and in what form, and whether tables
+ * can be restructured in place. Those are capabilities on the
+ * connection.
+ */
+export type JsonPathSegment = {
+    name: string;
+} | {
+    index: number;
+};
+/**
+ * A typed member path into the JSON document column: name segments for
+ * object members, index segments for array positions. Produced by the
+ * DDL planner (from analyzed index paths) and the patch translator
+ * (from pointers discriminated against the live document).
+ * @typedef {{ name: string } | { index: number }} JsonPathSegment
+ */
+/**
+ * Compose a dialect from its spelling spec. Every statement the store
+ * ever runs is built here from the spec's primitives, so a spec with
+ * different quoting or parameter style produces correspondingly
+ * different SQL from the same model — the property the test-double
+ * dialect pins.
+ * @param {{
+ *   name: string,
+ *   capabilities: Record<string, any>,
+ *   tableSuffix: string,
+ *   docColumnType: string,
+ *   quoteIdentifier: (s: string) => string,
+ *   parameterRef: (i: number, name: string) => string,
+ *   stringLiteral: (s: string) => string,
+ *   booleanLiteral: (b: boolean) => string,
+ *   typeFor: (schemaType: string | undefined, hint: string) => string,
+ *   limitClause: (limit: number, offset?: number) => string,
+ *   jsonPathText: (segments: JsonPathSegment[]) => string | null,
+ *   jsonExtract: (columnSql: string, pathText: string) => string,
+ *   jsonSet: (exprSql: string, pathText: string, valueSql: string) => string,
+ *   jsonRemove: (exprSql: string, pathText: string) => string,
+ *   jsonAppend: (exprSql: string, arrayPathText: string, valueSql: string) => string,
+ *   jsonEncode: (paramSql: string) => string,
+ *   jsonText: (columnSql: string) => string,
+ *   jsonAgg: (exprSql: string) => string,
+ *   jsonTypeOf: (columnSql: string, pathText: string) => string,
+ *   valueTypeOf: (paramSql: string) => string,
+ *   strStartsWith: (valueSql: string, patternA: string, patternB: string) => string,
+ *   strEndsWith: (valueSql: string, patternA: string, patternB: string, patternC: string) => string,
+ *   strContains: (valueSql: string, patternSql: string) => string,
+ *   orderNulls: (nullsFirst: boolean) => string,
+ *   rowIdentity: () => string,
+ *   explainQuery: (sql: string) => string,
+ *   excludedRef: (columnSql: string) => string,
+ *   tx: { begin: string, beginImmediate: string, commit: string,
+ *     rollback: string,
+ *     savepoint: (n: string) => string, release: (n: string) => string,
+ *     rollbackTo: (n: string) => string },
+ *   pragma: { busyTimeout: (ms: number) => string,
+ *     journalMode: (mode: string) => string,
+ *     foreignKeys: (on: boolean) => string },
+ *   introspect: { version: () => string, compileOptions: () => string,
+ *     tableExists: () => string, columns: (table: string) => string,
+ *     indexes: (table: string) => string,
+ *     indexColumns: (index: string) => string,
+ *     foreignKeysOn: () => string,
+ *     foreignKeyList: (table: string) => string },
+ * }} spec
+ * @returns {any} the frozen dialect
+ */
+export declare function createDialect(spec: {
+    name: string;
+    capabilities: Record<string, any>;
+    tableSuffix: string;
+    docColumnType: string;
+    quoteIdentifier: (s: string) => string;
+    parameterRef: (i: number, name: string) => string;
+    stringLiteral: (s: string) => string;
+    booleanLiteral: (b: boolean) => string;
+    typeFor: (schemaType: string | undefined, hint: string) => string;
+    limitClause: (limit: number, offset?: number) => string;
+    jsonPathText: (segments: JsonPathSegment[]) => string | null;
+    jsonExtract: (columnSql: string, pathText: string) => string;
+    jsonSet: (exprSql: string, pathText: string, valueSql: string) => string;
+    jsonRemove: (exprSql: string, pathText: string) => string;
+    jsonAppend: (exprSql: string, arrayPathText: string, valueSql: string) => string;
+    jsonEncode: (paramSql: string) => string;
+    jsonText: (columnSql: string) => string;
+    jsonAgg: (exprSql: string) => string;
+    jsonTypeOf: (columnSql: string, pathText: string) => string;
+    valueTypeOf: (paramSql: string) => string;
+    strStartsWith: (valueSql: string, patternA: string, patternB: string) => string;
+    strEndsWith: (valueSql: string, patternA: string, patternB: string, patternC: string) => string;
+    strContains: (valueSql: string, patternSql: string) => string;
+    orderNulls: (nullsFirst: boolean) => string;
+    rowIdentity: () => string;
+    explainQuery: (sql: string) => string;
+    excludedRef: (columnSql: string) => string;
+    tx: {
+        begin: string;
+        beginImmediate: string;
+        commit: string;
+        rollback: string;
+        savepoint: (n: string) => string;
+        release: (n: string) => string;
+        rollbackTo: (n: string) => string;
+    };
+    pragma: {
+        busyTimeout: (ms: number) => string;
+        journalMode: (mode: string) => string;
+        foreignKeys: (on: boolean) => string;
+    };
+    introspect: {
+        version: () => string;
+        compileOptions: () => string;
+        tableExists: () => string;
+        columns: (table: string) => string;
+        indexes: (table: string) => string;
+        indexColumns: (index: string) => string;
+        foreignKeysOn: () => string;
+        foreignKeyList: (table: string) => string;
+    };
+}): any;

package/dist/types/dialects/sqlite.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @file The SQLite dialect — the first spelling of the dialect
+ * contract, not the only conceivable one. Documents are stored JSONB
+ * in a BLOB column of a STRICT table; indexed paths become virtual
+ * generated columns over `jsonb_extract`; reads render back to text
+ * through `json()`. Parameters are positional (`?`) because every
+ * binding this package ships binds arrays.
+ */
+export declare const sqliteDialect: any;