@crvouga/mockingbird-service-sqlite 0.1.0

package/dist/vtable/fts/options.d.ts

@@ -0,0 +1,34 @@
+export type FtsKind = "fts5" | "fts3" | "fts4";
+export type FtsDetail = "full" | "column" | "none";
+export interface FtsColumnDef {
+    name: string;
+    unindexed: boolean;
+}
+export interface FtsTokenizerConfig {
+    /** Primary tokenizer name (unicode61, ascii, porter, trigram). */
+    name: string;
+    /** Base tokenizer when name is porter. */
+    base?: string;
+    removeDiacritics?: 0 | 1 | 2;
+    tokenchars?: string;
+    separators?: string;
+    caseSensitive?: boolean;
+    removeDiacriticsTrigram?: boolean;
+}
+export interface FtsTableOptions {
+    columns: FtsColumnDef[];
+    content: "normal" | "contentless" | "external";
+    contentTable: string | null;
+    contentRowid: string;
+    contentlessDelete: boolean;
+    prefix: number[];
+    columnsize: boolean;
+    detail: FtsDetail;
+    tokendata: boolean;
+    locale: boolean;
+    tokenizer: FtsTokenizerConfig;
+    /** FTS3/4 */
+    languageid: string | null;
+    notindexed: Set<string>;
+}
+export declare function parseFtsModuleArgs(moduleArgs: string[], kind: FtsKind): FtsTableOptions;

package/dist/vtable/fts/porter.d.ts

@@ -0,0 +1,2 @@
+/** Classic Porter stemming algorithm (English). */
+export declare function porterStem(word: string): string;

package/dist/vtable/fts/query.d.ts

@@ -0,0 +1,39 @@
+export type FtsQueryNode = {
+    type: "term";
+    value: string;
+    prefix: boolean;
+    column: string | null;
+    columns: string[] | null;
+} | {
+    type: "phrase";
+    terms: Array<{
+        value: string;
+        prefix: boolean;
+    }>;
+    column: string | null;
+    columns: string[] | null;
+} | {
+    type: "near";
+    children: FtsQueryNode[];
+    distance: number;
+    column: string | null;
+    columns: string[] | null;
+} | {
+    type: "and";
+    children: FtsQueryNode[];
+} | {
+    type: "or";
+    children: FtsQueryNode[];
+} | {
+    type: "not";
+    child: FtsQueryNode;
+} | {
+    type: "true";
+};
+/**
+ * Parse an FTS5 MATCH expression.
+ * Implicit AND between adjacent terms; OR binds looser than AND; NOT is binary (a NOT b).
+ */
+export declare function parseFts5Query(input: string): FtsQueryNode;
+/** FTS3/4 query parser (ENABLE_FTS3_PARENTHESIS style). */
+export declare function parseFts3Query(input: string): FtsQueryNode;

package/dist/vtable/fts/table.d.ts

@@ -0,0 +1,78 @@
+import type { Rowid } from "../../storage/row.js";
+import type { SqlValue } from "../../types/value.js";
+import { type FtsKind, type FtsTableOptions } from "./options.js";
+import { type FtsQueryNode } from "./query.js";
+import { type FtsToken, tokenizeFtsText } from "./tokenize.js";
+export interface Fts5Row {
+    rowid: Rowid;
+    values: Map<string, SqlValue>;
+    /** Per-column tokens with positions. */
+    tokensByColumn: Map<string, FtsToken[]>;
+}
+export interface FtsMatchHit {
+    column: string;
+    position: number;
+    startUnit: number;
+    endUnit: number;
+    term: string;
+}
+export interface FtsMatchCursor {
+    tableName: string;
+    rowid: Rowid;
+    query: string;
+    ast: FtsQueryNode;
+    hits: FtsMatchHit[];
+    /** Phrase term strings used for ranking (flattened). */
+    phraseTerms: string[][];
+}
+export declare class Fts5VirtualTable {
+    readonly kind: FtsKind;
+    readonly name: string;
+    readonly columns: string[];
+    readonly originalSql: string | null;
+    readonly options: FtsTableOptions;
+    readonly rows: Map<Rowid, Fts5Row>;
+    nextRowid: Rowid;
+    private readonly tokenize;
+    /** term -> postings */
+    private readonly index;
+    /** Global doc count for bm25. */
+    private docCount;
+    /** Average document length (tokens across indexed columns). */
+    private avgDocLen;
+    private totalTokens;
+    constructor(name: string, moduleArgs: string[], originalSql?: string | null, kind?: FtsKind);
+    scan(): Fts5Row[];
+    insert(values: Map<string, SqlValue>, rowid?: Rowid): Rowid;
+    update(rowid: Rowid, updates: Map<string, SqlValue>): void;
+    delete(rowid: Rowid): void;
+    matches(rowid: Rowid, leftTable: string | null, leftColumn: string, query: string): boolean;
+    matchCursor(rowid: Rowid, leftTable: string | null, leftColumn: string, query: string): FtsMatchCursor | null;
+    bm25(cursor: FtsMatchCursor, weights?: number[]): number;
+    highlight(cursor: FtsMatchCursor, colIndex: number, open: string, close: string): string;
+    snippet(cursor: FtsMatchCursor, colIndex: number, open: string, close: string, ellipsis: string, tokenCount: number): string;
+    /** FTS3/4 offsets(): "col phrase start length ..." */
+    offsets(cursor: FtsMatchCursor): string;
+    /** FTS3 matchinfo format encoded as native-style 32-bit little-endian integers. */
+    matchinfo(cursor: FtsMatchCursor, format?: string): Uint8Array;
+    vocabRows(mode: "row" | "col" | "instance"): Array<Record<string, SqlValue>>;
+    clone(): Fts5VirtualTable;
+    private detectCommand;
+    private runCommand;
+    private rebuild;
+    private buildRow;
+    private indexRow;
+    private unindexRow;
+    private addPosting;
+    private removePosting;
+    private indexedColumns;
+    private evalNode;
+    private normalizeQueryTerm;
+    /** For trigram tokenizer, a bare MATCH term is a phrase of overlapping trigrams. */
+    private expandTermNode;
+    private phraseFreq;
+    private phraseDocFreq;
+    private docLength;
+    private bumpRowid;
+}
+export { tokenizeFtsText };

package/dist/vtable/fts/tokenize.d.ts

@@ -0,0 +1,20 @@
+import type { FtsTokenizerConfig } from "./options.js";
+export interface FtsToken {
+    /** Normalized token text stored in the index. */
+    term: string;
+    /** Byte offset of the token in the UTF-8 encoding of the source. */
+    start: number;
+    /** Byte length in UTF-8. */
+    length: number;
+    /** Token position (0-based) within the column. */
+    position: number;
+    /** Original end offset in JS string code units (for highlight). */
+    startUnit: number;
+    endUnit: number;
+}
+export type TokenizerFn = (text: string) => FtsToken[];
+export declare function createTokenizer(config: FtsTokenizerConfig): TokenizerFn;
+export declare function utf8Length(text: string): number;
+export declare function utf8Offset(text: string, unitIndex: number): number;
+/** Legacy helper used by older call sites — simple alphanum split. */
+export declare function tokenizeFtsText(text: string): string[];

package/dist/vtable/fts5.d.ts

@@ -0,0 +1 @@
+export { type Fts5Row, Fts5VirtualTable, type FtsMatchCursor, tokenizeFtsText } from "./fts/table.js";

package/dist/vtable/index.d.ts

@@ -0,0 +1,2 @@
+export { type Fts5Row, Fts5VirtualTable, tokenizeFtsText } from "./fts5.js";
+export { BytecodeVirtualTable, DbStatVirtualTable, FtsVocabVirtualTable, RTreeVirtualTable, TablesUsedVirtualTable, } from "./modules.js";

package/dist/vtable/modules.d.ts

@@ -0,0 +1,65 @@
+import type { Rowid } from "../storage/row.js";
+import type { SqlValue } from "../types/value.js";
+export interface RTreeRow {
+    id: number | bigint;
+    coords: number[];
+}
+/**
+ * Simplified R*Tree for SQLite rtree / rtree_i32 modules.
+ * Stores axis-aligned boxes; queries filter by bound inequalities in WHERE.
+ */
+export declare class RTreeVirtualTable {
+    readonly kind: "rtree";
+    readonly name: string;
+    readonly columns: string[];
+    readonly dimension: number;
+    readonly integerCoords: boolean;
+    readonly originalSql: string | null;
+    readonly rows: Map<string, RTreeRow>;
+    /** Shadow node table content for rtreenode/rtreedepth. */
+    readonly nodes: Map<number, Uint8Array<ArrayBufferLike>>;
+    constructor(name: string, columns: string[], integerCoords?: boolean, originalSql?: string | null);
+    scan(): Array<{
+        rowid: Rowid;
+        values: Map<string, SqlValue>;
+    }>;
+    insert(values: Map<string, SqlValue>): Rowid;
+    update(rowid: Rowid, updates: Map<string, SqlValue>): void;
+    delete(rowid: Rowid): void;
+    clone(): RTreeVirtualTable;
+}
+export declare class DbStatVirtualTable {
+    readonly kind: "dbstat";
+    readonly name: string;
+    readonly columns: string[];
+    readonly originalSql: string | null;
+    readonly schemaArg: string | null;
+    constructor(name: string, schemaArg?: string | null, originalSql?: string | null);
+    clone(): DbStatVirtualTable;
+}
+export declare class BytecodeVirtualTable {
+    readonly kind: "bytecode";
+    readonly name: string;
+    readonly columns: string[];
+    readonly originalSql: string | null;
+    constructor(name: string, originalSql?: string | null);
+    clone(): BytecodeVirtualTable;
+}
+export declare class TablesUsedVirtualTable {
+    readonly kind: "tables_used";
+    readonly name: string;
+    readonly columns: string[];
+    readonly originalSql: string | null;
+    constructor(name: string, originalSql?: string | null);
+    clone(): TablesUsedVirtualTable;
+}
+export declare class FtsVocabVirtualTable {
+    readonly kind: "fts5vocab";
+    readonly name: string;
+    readonly columns: string[];
+    readonly ftsTable: string;
+    readonly vocabType: string;
+    readonly originalSql: string | null;
+    constructor(name: string, args: string[], originalSql?: string | null);
+    clone(): FtsVocabVirtualTable;
+}

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "@crvouga/mockingbird-service-sqlite",
+  "version": "0.1.0",
+  "description": "Pure TypeScript in-memory SQLite implementation with zero WASM/native dependencies",
+  "type": "module",
+  "license": "MIT",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./unstable": {
+      "types": "./dist/unstable.d.ts",
+      "import": "./dist/unstable.js",
+      "default": "./dist/unstable.js"
+    }
+  },
+  "files": [
+    "dist",
+    "AGENTS.md",
+    "COMPATIBILITY.md",
+    "COMPATIBILITY-AUDIT.md",
+    "README.md",
+    "LICENSE",
+    "compat"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/crvouga/mockingbird.git",
+    "directory": "packages/service/sqlite"
+  },
+  "homepage": "https://github.com/crvouga/mockingbird/tree/main/packages/service/sqlite#readme",
+  "bugs": {
+    "url": "https://github.com/crvouga/mockingbird/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "test": "bun test tests/contract tests/fuzz tests/harness",
+    "test:contract": "bun test tests/contract",
+    "test:fuzz": "bun test tests/fuzz",
+    "test:pbt": "bun test tests/fuzz",
+    "test:pbt:random": "bun run scripts/pbt-random.ts",
+    "test:fuzz:soak": "SQLITE_MEM_MIXED_STEPS=${SQLITE_MEM_MIXED_STEPS:-48} SQLITE_MEM_STATEFUL_STEPS=${SQLITE_MEM_STATEFUL_STEPS:-48} SQLITE_MEM_WALK_STEPS=${SQLITE_MEM_WALK_STEPS:-48} SQLITE_MEM_FUZZ_RUNS=${SQLITE_MEM_FUZZ_RUNS:-40} bun test tests/fuzz/mixed-stateful.test.ts tests/fuzz/stateful.test.ts tests/fuzz/random-walk.test.ts tests/fuzz/metamorphic tests/fuzz/robustness.test.ts tests/fuzz/sqllogictest.test.ts tests/fuzz/corpus.test.ts",
+    "test:metamorphic": "bun test tests/fuzz/metamorphic",
+    "test:sqllogictest": "bun test tests/fuzz/sqllogictest.test.ts",
+    "test:dst": "bun test tests/fuzz/stateful.test.ts tests/fuzz/mixed-stateful.test.ts tests/fuzz/random-walk.test.ts tests/fuzz/corpus.test.ts",
+    "test:walk": "bun test tests/fuzz/random-walk.test.ts",
+    "test:walk:soak": "bun run scripts/random-walk.ts",
+    "import:sqllogictest": "bun run scripts/import-sqllogictest.ts",
+    "example": "bun run --cwd examples/react-vite dev",
+    "benchmark": "bun run benchmarks/run.ts --tier default --engine mem",
+    "benchmark:bun": "bun run benchmarks/run.ts --tier full --engine both",
+    "benchmark:compare": "bun run benchmarks/run.ts --tier default --engine compare --grep compare/ --out benchmarks/results/compare-js.json",
+    "benchmark:compare-js": "bun run benchmarks/run.ts --tier default --engine compare-js --grep compare/js/ --out benchmarks/results/compare-js-only.json",
+    "benchmark:compare-sqlite": "bun run benchmarks/run.ts --tier default --engine compare-sqlite --grep compare/sqlite/ --out benchmarks/results/compare-sqlite.json",
+    "benchmark:ci": "bun run benchmarks/run.ts --tier ci --engine mem --out benchmarks/results/ci-latest.json && bun run benchmarks/compare-ci.ts && bun run benchmarks/check-budgets.ts",
+    "benchmark:memory": "bun run benchmarks/check-budgets.ts",
+    "benchmark:bundle": "bun run build && bun run benchmarks/bundle.ts",
+    "benchmark:report": "bun run benchmarks/report-html.ts",
+    "test:browser": "bun run build && bun run scripts/browser-perf.ts",
+    "test:browser-sql": "bun run build && bun run scripts/browser-sql-smoke.ts",
+    "test:canaries": "bun run scripts/run-canaries.ts",
+    "test:sqlite-compat": "bun run scripts/sqlite-compat-gate.ts && bun run scripts/check-skip-register.ts && bun test tests/contract tests/fuzz tests/harness",
+    "divergences": "bun run scripts/generate-divergences.ts",
+    "fixtures:browser": "bun run scripts/generate-browser-fixtures.ts",
+    "inventory": "bun run scripts/sqlite-inventory.ts",
+    "scenarios": "bun run scripts/sqlite-scenarios.ts",
+    "fts-surface": "bun run scripts/fts-oracle-surface.ts",
+    "requirements": "bun run scripts/sqlite-requirements.ts",
+    "typecheck": "tsc --noEmit",
+    "typecheck:package": "tsc --noEmit -p tsconfig.package.json",
+    "format": "biome format --config-path=biome.json --write .",
+    "format:check": "biome format --config-path=biome.json .",
+    "lint": "biome lint --config-path=biome.json --error-on-warnings .",
+    "lint:fix": "biome lint --config-path=biome.json --write --error-on-warnings .",
+    "clean": "rm -rf dist",
+    "check": "bun run format:check && bun run lint && bun run typecheck && bun run test:sqlite-compat",
+    "check:full": "bun run check && bun run build && bun run pack:check && bun run portability",
+    "verify-package": "bun run scripts/verify-package.ts",
+    "pack:check": "bun ../../../scripts/pack-check.ts",
+    "portability": "bun ../../../scripts/portability.ts",
+    "example:react-vite": "cd examples/react-vite && bun install && bun run dev",
+    "fc": "clear && bun format && bun check:full"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@biomejs/biome": "^2.5.8",
+    "@types/bun": "latest",
+    "alasql": "^4.17.3",
+    "esbuild": "^0.28.2",
+    "fast-check": "^4.1.1",
+    "publint": "^0.3.23",
+    "sql.js": "^1.14.2",
+    "typescript": "^5.8.3",
+    "wa-sqlite": "^1.0.0"
+  },
+  "engines": {
+    "bun": ">=1.1.0",
+    "node": ">=20"
+  },
+  "keywords": [
+    "mockingbird",
+    "sqlite",
+    "typescript",
+    "in-memory",
+    "database",
+    "sql"
+  ],
+  "mockingbird": {
+    "runtime": "portable",
+    "layer": "service"
+  }
+}