@crvouga/sqlite-mem 1.10.0 → 1.12.0

package/dist/indexes/index.d.ts

@@ -34,6 +34,8 @@ export declare class IndexStore {
         rowids: Rowid[];
     }>;
     rememberKeyValues(key: string, values: readonly SqlValue[]): void;
+    /** Key component values for snapshot encode (binary keys). */
+    keyValuesFor(key: string): SqlValue[];
     get size(): number;
     private orderedKeys;
     private assertMutable;

package/dist/serialization/codec.d.ts

@@ -1,27 +1,19 @@
 import { DatabaseState } from "../storage/database-state.js";
-/** PRNG + clock captured alongside schema/rows in a v2 snapshot. */
+/** PRNG + clock captured alongside schema/rows. */
 export interface SnapshotRuntime {
-    /** Unsigned 64-bit {@link Prng} state. */
     prngState: bigint;
-    /** Clock instant as milliseconds since Unix epoch. */
     nowMs: number;
 }
 /** Result of {@link decodeDatabaseState}. */
 export interface DecodedSnapshot {
-    /** Restored catalog and table data. */
     state: DatabaseState;
-    /** Present for v2+ snapshots; `null` for v1 (schema/rows only). */
-    runtime: SnapshotRuntime | null;
+    runtime: SnapshotRuntime;
 }
 /**
  * Encode catalog, rows, and runtime into a sqlite-mem snapshot blob (not a `.sqlite` file).
- *
- * Prefer {@link Database.snapshot} unless you are serializing engine state directly.
  */
-export declare function encodeDatabaseState(state: DatabaseState, runtime: SnapshotRuntime, formatVersion?: number): Uint8Array;
+export declare function encodeDatabaseState(state: DatabaseState, runtime: SnapshotRuntime): Uint8Array;
 /**
  * Decode a blob from {@link encodeDatabaseState} / {@link Database.snapshot}.
- *
- * @throws {SqliteError} If the magic, version, or payload is invalid.
  */
 export declare function decodeDatabaseState(snapshot: Uint8Array): DecodedSnapshot;

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/table.d.ts

@@ -1,6 +1,7 @@
 import type { Expr, TableConstraint } from "../ast/nodes.js";
 import type { Affinity, SqlValue } from "../types/value.js";
 import type { Row, Rowid, RowValues } from "./row.js";
+import type { ColumnarSlab } from "./columnar-slab.js";
 export interface ColumnInfo {
     name: string;
     /** Cached `name.toLowerCase()` for hot-path lookups. */
@@ -49,6 +50,8 @@ export declare class Table {
     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;
@@ -67,6 +70,16 @@ export declare class Table {
     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;