@crvouga/mockingbird-service-sqlite 0.1.0

package/dist/serialization/wire.d.ts

@@ -0,0 +1,61 @@
+export declare function writeVarintU32(w: Writer, value: number): void;
+export declare function readVarintU32(r: Reader): number;
+export declare class Writer {
+    private buf;
+    private view;
+    private len;
+    constructor(capacity?: number);
+    get position(): number;
+    reserve(capacity: number): void;
+    private ensure;
+    align4(): void;
+    u8(value: number): void;
+    u32(value: number): void;
+    u64(value: bigint): void;
+    i64(value: bigint): void;
+    f64(value: number): void;
+    raw(value: Uint8Array): void;
+    rawAt(offset: number, value: Uint8Array): void;
+    /** Length-prefixed UTF-8 via encodeInto when possible. */
+    text(value: string): void;
+    /** Write UTF-8 at current position without length prefix (intern blob region). */
+    textBytes(value: string): void;
+    finish(): Uint8Array;
+    fail(): never;
+}
+export declare class Reader {
+    private readonly bytes;
+    private offset;
+    private readonly view;
+    constructor(bytes: Uint8Array);
+    get position(): number;
+    skipAlign4(): void;
+    u8(): number;
+    u32(): number;
+    u64(): bigint;
+    i64(): bigint;
+    f64(): number;
+    raw(length: number): Uint8Array;
+    text(): string;
+    remaining(): number;
+    done(): boolean;
+    fail(): never;
+}
+export declare function writeBjv(w: Writer, value: unknown, forceIntern: (s: string) => number): void;
+export declare function readBjv(r: Reader, intern: readonly string[]): unknown;
+export declare class InternPool {
+    private readonly counts;
+    private readonly ids;
+    readonly list: string[];
+    constructor();
+    count(s: string): void;
+    /** Assign ids only to strings seen ≥2 times (plus empty string). */
+    finalize(): void;
+    /** Always intern (schema / catalog strings). */
+    forceId(s: string): number;
+    id(s: string): number;
+    has(s: string): boolean;
+}
+/** Write intern table: count, offsets[], concatenated UTF-8 blob. */
+export declare function writeInternTable(w: Writer, strings: readonly string[]): void;
+export declare function readInternTable(r: Reader): string[];

package/dist/storage/columnar-slab.d.ts

@@ -0,0 +1,58 @@
+import { type SqlValue } from "../types/value.js";
+import type { Rowid } from "./row.js";
+/** Column pack tags (SQLM v5). */
+export declare const PACK_NULL = 0;
+export declare const PACK_I32 = 1;
+export declare const PACK_I64 = 2;
+export declare const PACK_F64 = 3;
+export declare const PACK_TEXT_INTERN = 4;
+export declare const PACK_TEXT_INLINE = 5;
+export declare const PACK_BLOB = 6;
+export declare const PACK_TAGGED = 7;
+export interface SlabColumn {
+    pack: number;
+    nullBitmap: Uint8Array | null;
+    /** Typed payload or inline blob region inside `buffer`. */
+    payload: Uint8Array;
+    /** Cached view over `payload` (avoid per-cell DataView alloc). */
+    view?: DataView;
+    /** Prefix count of non-null cells before each row (when nulls exist). */
+    nonNullRank?: Uint32Array;
+    /** For PACK_TEXT_INLINE: u32 offsets into payload per row. */
+    inlineOffsets?: Uint32Array;
+    /** For PACK_TAGGED: decoded values per non-null row in order. */
+    tagged?: SqlValue[];
+    /** For PACK_BLOB: one entry per non-null row. */
+    blobChunks?: Uint8Array[];
+}
+/** Attach decode helpers; drop an all-zero null bitmap. */
+export declare function prepareSlabColumn(column: SlabColumn, rowCount: number, nonNull: number): SlabColumn;
+/** Frozen columnar row storage; zero-copy views into snapshot buffer. */
+export declare class ColumnarSlab {
+    readonly buffer: Uint8Array;
+    readonly rowCount: number;
+    readonly rowids: Rowid[];
+    readonly columns: SlabColumn[];
+    private readonly intern;
+    private rowidIndex;
+    constructor(buffer: Uint8Array, rowCount: number, rowids: Rowid[], columns: SlabColumn[], intern: readonly string[]);
+    private rowIndex;
+    cell(rowIndex: number, col: number): SqlValue;
+    rowAt(rowIndex: number): {
+        rowid: Rowid;
+        values: SqlValue[];
+    };
+    get(rowid: Rowid): {
+        rowid: Rowid;
+        values: SqlValue[];
+    } | undefined;
+    scan(): Generator<{
+        rowid: Rowid;
+        values: SqlValue[];
+    }>;
+    materialize(): Map<Rowid, {
+        rowid: Rowid;
+        values: SqlValue[];
+    }>;
+}
+export declare function packKindOf(value: SqlValue): number;

package/dist/storage/database-state.d.ts

@@ -0,0 +1,96 @@
+import type { CreateIndexStmt, CreateTableStmt, CreateViewStmt, CreateVirtualTableStmt, Expr, IndexedColumn, SelectStmt } from "../ast/nodes.js";
+import { IndexStore } from "../indexes/index.js";
+import { Fts5VirtualTable } from "../vtable/fts5.js";
+import { BytecodeVirtualTable, DbStatVirtualTable, FtsVocabVirtualTable, RTreeVirtualTable, TablesUsedVirtualTable } from "../vtable/modules.js";
+import type { Rowid } from "./row.js";
+import { Table } from "./table.js";
+export type AnyVirtualTable = Fts5VirtualTable | RTreeVirtualTable | DbStatVirtualTable | BytecodeVirtualTable | TablesUsedVirtualTable | FtsVocabVirtualTable;
+export interface ViewInfo {
+    name: string;
+    columns: string[] | null;
+    select: SelectStmt;
+    originalSql: string | null;
+}
+export interface IndexInfo {
+    name: string;
+    tableName: string;
+    unique: boolean;
+    columns: IndexedColumn[];
+    where: Expr | null;
+    originalSql: string | null;
+    store: IndexStore;
+}
+export interface TriggerInfo {
+    name: string;
+    tableName: string;
+    timing: "BEFORE" | "AFTER" | "INSTEAD";
+    event: "INSERT" | "UPDATE" | "DELETE";
+    when: Expr | null;
+    forEachRow: boolean;
+    /** Statements in the trigger body (already parsed). */
+    body: import("../ast/nodes.js").Statement[];
+    updateColumns: string[] | null;
+    originalSql: string | null;
+}
+/** In-memory catalog: tables, indexes, views, triggers, and mutation counters. */
+export declare class DatabaseState {
+    tables: Map<string, Table>;
+    virtualTables: Map<string, AnyVirtualTable>;
+    views: Map<string, ViewInfo>;
+    indexes: Map<string, IndexInfo>;
+    triggers: Map<string, TriggerInfo>;
+    /** Attached databases: schema name → state + filename label. */
+    attached: Map<string, {
+        state: DatabaseState;
+        filename: string;
+    }>;
+    lastInsertRowid: Rowid;
+    changes: number;
+    totalChanges: number;
+    foreignKeysEnabled: boolean;
+    /** When true, LIKE / like() are case-sensitive (SQLite `PRAGMA case_sensitive_like`). */
+    caseSensitiveLike: boolean;
+    schemaVersion: number;
+    userVersion: number;
+    databaseForSchema(schema: string | null, qualifiedForError?: string): DatabaseState;
+    databaseForTable(table: Table): DatabaseState;
+    getTable(name: string): Table;
+    getVirtualTable(name: string): Fts5VirtualTable;
+    getAnyVirtualTable(name: string): AnyVirtualTable;
+    isVirtualTable(name: string): boolean;
+    isFtsTable(name: string): boolean;
+    createVirtualTable(stmt: CreateVirtualTableStmt, originalSql?: string | null): AnyVirtualTable;
+    createTable(stmt: CreateTableStmt, originalSql?: string | null): Table;
+    /**
+     * SQLite-like autoindexes for PRIMARY KEY / UNIQUE so lookups and uniqueness
+     * checks can use IndexStore. Skips single-column INTEGER PRIMARY KEY (rowid alias).
+     */
+    private createAutoIndexesForTable;
+    dropTable(name: string, ifExists?: boolean): boolean;
+    renameTable(oldName: string, newName: string): Table;
+    createView(stmt: CreateViewStmt, originalSql?: string | null): ViewInfo;
+    dropView(name: string, ifExists?: boolean): boolean;
+    createIndex(stmt: CreateIndexStmt, originalSql?: string | null): IndexInfo;
+    dropIndex(name: string, ifExists?: boolean): boolean;
+    createTrigger(info: TriggerInfo): TriggerInfo;
+    dropTrigger(name: string, ifExists?: boolean): boolean;
+    dropTriggersForTable(tableName: string): void;
+    recordChange(count: number, lastInsertRowid?: Rowid): void;
+    clone(): DatabaseState;
+    /** Share table/index objects with the live state. Callers must freeze first. */
+    cloneShallow(): DatabaseState;
+    freezeShared(): void;
+    thawShared(): void;
+    getWritableTable(name: string): Table;
+    ensureWritableTable(table: Table): Table;
+    getWritableIndex(name: string): IndexInfo;
+    ensureWritableIndex(index: IndexInfo): IndexInfo;
+    replaceWith(state: DatabaseState, options?: {
+        adopt?: boolean;
+    }): void;
+    private assertSchemaNameAvailable;
+}
+export declare function splitQualifiedName(name: string): {
+    schema: string | null;
+    bare: string;
+};

package/dist/storage/index.d.ts

@@ -0,0 +1,6 @@
+export type { IndexInfo, ViewInfo } from "./database-state.js";
+export { DatabaseState } from "./database-state.js";
+export type { Row, Rowid, RowValues } from "./row.js";
+export { cloneRow, normalizeColumnName, rowValues } from "./row.js";
+export type { ColumnInfo, InsertRow, TableOptions } from "./table.js";
+export { makeColumnInfo, Table } from "./table.js";

package/dist/storage/row.d.ts

@@ -0,0 +1,13 @@
+import type { SqlValue } from "../types/value.js";
+export type Rowid = number | bigint;
+/** Heap row: `values[i]` is `table.columns[i]`. */
+export interface Row {
+    rowid: Rowid;
+    values: SqlValue[];
+}
+export type NamedRowValues = Map<string, SqlValue> | ReadonlyMap<string, SqlValue> | Record<string, SqlValue>;
+export type RowValues = NamedRowValues | readonly SqlValue[];
+export declare function normalizeColumnName(name: string): string;
+export declare function rowValues(values: NamedRowValues): Map<string, SqlValue>;
+export declare function cloneRow(row: Row): Row;
+export declare function isValueArray(values: RowValues): values is readonly SqlValue[];

package/dist/storage/table.d.ts

@@ -0,0 +1,119 @@
+import type { Expr, TableConstraint } from "../ast/nodes.js";
+import type { Affinity, SqlValue } from "../types/value.js";
+import type { ColumnarSlab } from "./columnar-slab.js";
+import type { Row, Rowid, RowValues } from "./row.js";
+export interface ColumnInfo {
+    name: string;
+    /** Cached `name.toLowerCase()` for hot-path lookups. */
+    nameLower?: string;
+    typeName: string | null;
+    affinity: Affinity;
+    notNull: boolean;
+    primaryKey: boolean;
+    autoincrement: boolean;
+    defaultExpr: Expr | null;
+    unique: boolean;
+    /** Declared column collation (BINARY/NOCASE/RTRIM); null means BINARY. */
+    collate: string | null;
+    /** GENERATED ALWAYS AS (...) — VIRTUAL computed on read, STORED materialized. */
+    generated: {
+        expr: Expr;
+        stored: boolean;
+    } | null;
+}
+export interface InsertOptions {
+    /** Values are already affinity-applied Maps with lowercase keys; skip prepareValues. */
+    prepared?: boolean;
+    /** Skip NOT NULL / UNIQUE / PK scans (caller already enforced, or table is unconstrained). */
+    skipValidate?: boolean;
+}
+export interface InsertRow {
+    rowid?: Rowid;
+    values: RowValues;
+}
+export interface TableOptions {
+    constraints?: TableConstraint[];
+    indexes?: string[];
+    originalSql?: string | null;
+    withoutRowid?: boolean;
+    strict?: boolean;
+}
+export declare class Table {
+    name: string;
+    columns: ColumnInfo[];
+    rows: Map<Rowid, Row>;
+    nextRowid: Rowid;
+    constraints: TableConstraint[];
+    indexes: string[];
+    originalSql: string | null;
+    withoutRowid: boolean;
+    strict: boolean;
+    /** Clustered PK key string → row for WITHOUT ROWID tables. */
+    clusteredRows: Map<string, Row>;
+    /** Frozen columnar storage after snapshot hydrate; `rows` stays empty until materialized. */
+    slab: ColumnarSlab | null;
+    private scanCache;
+    /** Lazy covering hashes: column nameLower → serializeIndexKey → rowids. */
+    private equalityHashes;
+    /** Cached maximum rowid. `undefined` means recompute after deleting the maximum. */
+    private maximumRowid;
+    frozen: boolean;
+    /** nameLower → column index; rebuilt after ALTER. */
+    private colIndex;
+    constructor(name: string, columns: ColumnInfo[], options?: TableOptions);
+    rebuildColIndex(): void;
+    columnOffset(nameLower: string): number | undefined;
+    hasColumn(nameLower: string): boolean;
+    cell(row: Row, nameLower: string): SqlValue;
+    setCell(row: Row, nameLower: string, value: SqlValue): void;
+    namedValues(row: Row): Map<string, SqlValue>;
+    rowFromNamed(values: Map<string, SqlValue>, rowid?: Rowid): Row;
+    integerPkColumn(): ColumnInfo | undefined;
+    get(rowid: Rowid): Row | undefined;
+    /** Row count (slab-backed or map-backed). */
+    rowCount(): number;
+    /** Rows sorted by rowid for snapshot encode. */
+    sortedRows(): Row[];
+    /** Attach decoded columnar slab (hydrate path). */
+    attachSlab(slab: ColumnarSlab): void;
+    /** Materialize slab into `rows` Map for mutation. */
+    materializeSlab(): void;
+    private hasRow;
+    private allRowids;
+    getByKey(value: SqlValue): Row | undefined;
+    private invalidateScan;
+    private commitRow;
+    private reindexEquality;
+    /** True when the table has no user constraints that DML must enforce beyond hidden rowid. */
+    isUnconstrained(): boolean;
+    /**
+     * Point lookup via a write-maintained covering hash (not a schema index).
+     * Returns null when the table is too small or the column does not exist.
+     */
+    lookupEquality(columnLower: string, value: SqlValue): Row[] | null;
+    ensureEqualityHash(columnLower: string): boolean;
+    clearEqualityHashes(): void;
+    private indexEquality;
+    private unindexEquality;
+    insert(input: InsertRow | RowValues, options?: InsertOptions): Rowid;
+    update(rowid: Rowid, updates: RowValues): Row | undefined;
+    delete(rowid: Rowid): boolean;
+    scan(): Iterable<Row>;
+    clone(): Table;
+    freeze(): void;
+    private assertMutable;
+    /** Rebuild clustered storage after snapshot decode or bulk load. */
+    rebuildClusteredRows(): void;
+    private cellsFromInput;
+    private prepareValues;
+    private column;
+    private validate;
+    private uniqueColumnSets;
+    private primaryKeyColumns;
+    private makeClusterKey;
+    private comparePrimaryKeys;
+    private integerPrimaryKeyAlias;
+    private allocateRowid;
+    private advanceNextRowid;
+}
+export declare function makeColumnInfo(name: string, typeName: string | null, options?: Partial<Omit<ColumnInfo, "name" | "nameLower" | "typeName" | "affinity">>): ColumnInfo;

package/dist/transactions/manager.d.ts

@@ -0,0 +1,19 @@
+import type { Prng } from "../runtime/prng.js";
+import type { DatabaseState } from "../storage/database-state.js";
+export declare class TransactionManager {
+    readonly state: DatabaseState;
+    readonly prng: Prng;
+    private transactionSnapshot;
+    private transactionPrngState;
+    private savepoints;
+    private startedBySavepoint;
+    constructor(state: DatabaseState, prng: Prng);
+    get inTransaction(): boolean;
+    begin(): void;
+    commit(): void;
+    rollback(savepoint?: string): void;
+    savepoint(name: string): void;
+    release(name: string): void;
+    private findSavepoint;
+    private requireTransaction;
+}

package/dist/types/collation.d.ts

@@ -0,0 +1,4 @@
+import { type SqlValue } from "./value.js";
+export type BuiltinCollation = "BINARY" | "NOCASE" | "RTRIM";
+export declare function normalizeForCollation(value: SqlValue, name: string): SqlValue;
+export declare function compareWithCollation(a: SqlValue, b: SqlValue, name: string): number | null;

package/dist/types/sqlite-atof.d.ts

@@ -0,0 +1,4 @@
+/** SQLite 3.51 `sqlite3AtoF` (decimal text → IEEE754 double). */
+export declare function dekkerMul2(rr: [number, number], y: number, yy: number): void;
+/** Parse a decimal float text literal the way SQLite 3.51 does. */
+export declare function sqliteAtoF(zIn: string): number;

package/dist/types/sqlite-real-format.d.ts

@@ -0,0 +1,5 @@
+/**
+ * SQLite 3.51 REAL → text formatting (`%!.15g`), ported from sqlite3FpDecode + etGENERIC.
+ */
+/** `%!.15g` for REAL→TEXT (etGENERIC + flag_altform2). */
+export declare function formatRealAsTextSqlite(value: number): string;

package/dist/types/strict.d.ts

@@ -0,0 +1,6 @@
+import { type SqlValue } from "./value.js";
+export declare function isStrictTypeName(typeName: string | null | undefined): boolean;
+export declare function applyStrictValue(value: SqlValue, typeName: string, table: string, column: string): SqlValue;
+export declare function unknownStrictType(table: string, column: string, typeName: string): never;
+/** SQLite reports INT for the integer storage class in STRICT errors. */
+export declare function strictStorageLabel(value: SqlValue): string;

package/dist/types/value.d.ts

@@ -0,0 +1,88 @@
+/** SQLite storage class of a {@link SqlValue} (`null` / `integer` / `real` / `text` / `blob`). */
+export type StorageClass = "null" | "integer" | "real" | "text" | "blob";
+/** Integer-valued REAL that must not collapse to the integer storage class. */
+export declare class SqlReal {
+    /** IEEE float payload (`-0` already canonicalized to `+0`). */
+    readonly value: number;
+    constructor(value: number);
+    valueOf(): number;
+    toString(): string;
+}
+/** SQLite JSON subtype (74 / 'J') — text that nested JSON APIs treat as JSON, not a string. */
+export declare const JSON_SUBTYPE = 74;
+/** TEXT value with SQLite JSON subtype 74 — nested JSON APIs treat it as JSON, not a string. */
+export declare class SqlJsonText {
+    readonly value: string;
+    readonly subtype = 74;
+    constructor(value: string);
+    valueOf(): string;
+    toString(): string;
+}
+/** A SQLite value: NULL, integer/real, text, blob, or a typed REAL/JSON wrapper. */
+export type SqlValue = null | number | bigint | string | Uint8Array | SqlReal | SqlJsonText;
+/**
+ * A value as it appears in query result rows.
+ * {@link SqlReal} and {@link SqlJsonText} wrappers are unwrapped at the JS API surface.
+ */
+export type QueryValue = null | number | bigint | string | Uint8Array;
+/** A result row keyed by column name. Duplicate SELECT names keep the last value. */
+export type QueryRow = Record<string, QueryValue>;
+/**
+ * Values accepted by bind slots (`?`, `?NNN`, `:name`, `@name`, `$name`).
+ * Booleans become integer 0/1; {@link ArrayBuffer} is copied as a BLOB.
+ */
+export type BindValue = SqlValue | boolean | ArrayBuffer;
+/** Column type affinity from a declared type name (SQLite affinity rules). */
+export type Affinity = "TEXT" | "NUMERIC" | "INTEGER" | "REAL" | "BLOB";
+/** Canonicalize IEEE `-0` to `+0` for cross-runtime determinism. */
+export declare function canonicalizeNumber(value: number): number;
+/** Wrap `value` as {@link SqlReal} so it stays REAL even when it is an integer. */
+export declare function asSqlReal(value: number): SqlReal;
+/** `true` when `value` is a {@link SqlReal} wrapper. */
+export declare function isSqlReal(value: SqlValue): value is SqlReal;
+/** `true` when `value` is a {@link SqlJsonText} wrapper. */
+export declare function isSqlJsonText(value: SqlValue): value is SqlJsonText;
+/** Wrap `value` as {@link SqlJsonText} (JSON subtype 74). */
+export declare function asSqlJsonText(value: string): SqlJsonText;
+/** Strip ephemeral JSON subtype for table storage / non-JSON contexts. */
+export declare function unwrapSqlValue(value: SqlValue): SqlValue;
+export declare function subtypeOf(value: SqlValue): number;
+export declare function numberValueOf(value: number | bigint | SqlReal): number;
+/** SQLite storage class of `value` (`null` / `integer` / `real` / `text` / `blob`). */
+export declare function storageClassOf(value: SqlValue): StorageClass;
+/** SQLite `typeof()` string for `value`. */
+export declare function typeofSql(value: SqlValue): string;
+/** Determine column affinity from a declared type name (SQLite rules). */
+export declare function affinityFromTypeName(typeName: string | null | undefined): Affinity;
+/** Apply column {@link Affinity} conversion rules to `value`. */
+export declare function applyAffinity(value: SqlValue, affinity: Affinity): SqlValue;
+/** Format a REAL for TEXT affinity / CAST AS TEXT (SQLite `%!.15g`). */
+export declare function formatRealAsText(value: number): string;
+/**
+ * Apply SQLite comparison affinity rules before comparing two values.
+ * A null affinity represents an expression with no affinity.
+ */
+export declare function applyComparisonAffinity(left: SqlValue, right: SqlValue, leftAffinity: Affinity | null, rightAffinity: Affinity | null): [SqlValue, SqlValue];
+/** Prefix numeric parse for arithmetic / boolean (sqlite3AtoF). */
+export declare function coerceToNumberPrefix(value: SqlValue): number;
+/** Parse `value` as a number, or `null` when it is not numeric. */
+export declare function coerceToNumber(value: SqlValue): number | null;
+/** Truncate `value` toward zero as an integer, or `null` when it is not numeric. */
+export declare function toInteger(value: SqlValue): number | bigint | null;
+/** SQLite `=` / `IS` equality for two non-NULL values (`NULL = NULL` is false here). */
+export declare function sqlValueEquals(a: SqlValue, b: SqlValue): boolean;
+/**
+ * SQLite comparison for ORDER BY / inequalities.
+ * Returns -1, 0, 1, or null if either side is NULL (SQL NULL).
+ */
+export declare function compareSql(a: SqlValue, b: SqlValue): number | null;
+export declare function utf8Encode(s: string): Uint8Array;
+/** UTF-8 decode `b` (SQLite BLOB → TEXT). */
+export declare function utf8Decode(b: Uint8Array): string;
+/** Deep-copy blobs and REAL/JSON wrappers; primitives are returned as-is. */
+export declare function cloneSqlValue(v: SqlValue): SqlValue;
+/**
+ * SQLite boolean truthiness (WHERE / HAVING / CASE / AND / OR / NOT).
+ * Text/blob use longest-prefix numeric conversion (sqlite3AtoF); non-numeric → 0.
+ */
+export declare function isTruthySql(v: SqlValue): boolean | null;

package/dist/unstable.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @packageDocumentation
+ * Unstable internals for advanced tooling and the sqlite-mem test suite.
+ *
+ * **Exempt from semver.** Anything exported from `@crvouga/mockingbird-service-sqlite/unstable`
+ * may change or be removed in any release (including patch). Prefer the stable
+ * entry `@crvouga/mockingbird-service-sqlite` for application code.
+ *
+ * @module
+ */
+export type { Expr } from "./ast/nodes.js";
+export type { EvalContext } from "./expressions/context.js";
+export { evalExpr } from "./expressions/eval.js";
+export { globMatch, likeMatch } from "./expressions/like.js";
+export { type Token, type TokenKind, tokenize } from "./lexer/tokenize.js";
+export { type ParsedStatement, parse } from "./parser/index.js";
+export { type Clock, DEFAULT_DATABASE_SEED, DEFAULT_NOW, deriveSeed, fixedClock, OsEntropy, Prng, type RandomMode, resolveClock, systemClock, } from "./runtime/index.js";
+export { type DecodedSnapshot, decodeDatabaseState, encodeDatabaseState, type SnapshotRuntime, } from "./serialization/index.js";
+export type { DatabaseState } from "./storage/database-state.js";
+export { type Affinity, affinityFromTypeName, applyAffinity, asSqlJsonText, asSqlReal, canonicalizeNumber, cloneSqlValue, coerceToNumber, compareSql, isSqlJsonText, isSqlReal, isTruthySql, SqlJsonText, SqlReal, type SqlValue, type StorageClass, sqlValueEquals, storageClassOf, toInteger, typeofSql, utf8Decode, utf8Encode, } from "./types/value.js";