@livestore/sqlite-wasm 0.4.0-dev.2 → 0.4.0-dev.5

package/dist/browser/mod.d.ts

@@ -1,4 +1,5 @@
 import type { MakeSqliteDb, PersistenceInfo, SqliteDb } from '@livestore/common';
+import type { SQLiteAPI } from '@livestore/wa-sqlite';
 import type { MemoryVFS } from '@livestore/wa-sqlite/src/examples/MemoryVFS.js';
 import type { AccessHandlePoolVFS } from './opfs/AccessHandlePoolVFS.ts';
 export * from './opfs/opfs-sah-pool.ts';

package/dist/browser/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/browser/mod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAEhF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gDAAgD,CAAA;AAI/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAA;AAGxE,cAAc,yBAAyB,CAAA;AAEvC,MAAM,MAAM,2BAA2B,GAAG;IACxC,IAAI,EAAE,WAAW,CAAA;IACjB,GAAG,EAAE,SAAS,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,eAAe,CAAA;IAChC,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,WAAW,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,mBAAmB,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,eAAe,CAAC;QAC/B,aAAa,EAAE,MAAM,CAAA;QACrB,mCAAmC;QACnC,YAAY,EAAE,MAAM,CAAA;KACrB,CAAC,CAAA;IACF,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,WAAW,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,2BAA2B,GAAG,uBAAuB,CAAA;AAEvF,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,WAAW,CAAA;IACjB,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAA;CACrC,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,wFAAwF;IACxF,QAAQ,EAAE,MAAM,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAA;CACrC,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,wBAAwB,GAAG,oBAAoB,CAAA;AAE9E,MAAM,MAAM,eAAe,GAAG,YAAY,CACxC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,eAAe,CAAA;CAAE,EACvD,gBAAgB,EAChB,mBAAmB,CACpB,CAAA;AAED,eAAO,MAAM,eAAe,GACzB,aAAa;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,KAAG,eAqDnC,CAAA"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/browser/mod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAEhF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gDAAgD,CAAA;AAI/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAA;AAGxE,cAAc,yBAAyB,CAAA;AAEvC,MAAM,MAAM,2BAA2B,GAAG;IACxC,IAAI,EAAE,WAAW,CAAA;IACjB,GAAG,EAAE,SAAS,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,eAAe,CAAA;IAChC,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,WAAW,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,mBAAmB,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,eAAe,CAAC;QAC/B,aAAa,EAAE,MAAM,CAAA;QACrB,mCAAmC;QACnC,YAAY,EAAE,MAAM,CAAA;KACrB,CAAC,CAAA;IACF,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,WAAW,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,2BAA2B,GAAG,uBAAuB,CAAA;AAEvF,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,WAAW,CAAA;IACjB,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAA;CACrC,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,wFAAwF;IACxF,QAAQ,EAAE,MAAM,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAA;CACrC,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,wBAAwB,GAAG,oBAAoB,CAAA;AAE9E,MAAM,MAAM,eAAe,GAAG,YAAY,CACxC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,eAAe,CAAA;CAAE,EACvD,gBAAgB,EAChB,mBAAmB,CACpB,CAAA;AAED,eAAO,MAAM,eAAe,GACzB,aAAa;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,KAAG,eAqDnC,CAAA"}

package/dist/browser/mod.js.map

@@ -1 +1 @@
-{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../src/browser/mod.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAA;AAGtD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAEnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C,cAAc,yBAAyB,CAAA;AA+CvC,MAAM,CAAC,MAAM,eAAe,GAC1B,CAAC,EAAE,OAAO,EAA0B,EAAmB,EAAE,CACzD,CAAC,KAAuB,EAAE,EAAE,CAC1B,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;QAC/B,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,OAAO,CAAC,CAAA;QAClD,OAAO,YAAY,CAA8B;YAC/C,OAAO;YACP,QAAQ,EAAE;gBACR,IAAI,EAAE,WAAW;gBACjB,GAAG;gBACH,SAAS;gBACT,QAAQ,EAAE,GAAG,EAAE,GAAE,CAAC;gBAClB,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;gBAC5C,eAAe,EAAE;oBACf,QAAQ,EAAE,UAAU;iBACrB;aACF;SACF,CAAQ,CAAA;IACX,CAAC;IAED,wCAAwC;IACxC,MAAM,sBAAsB,GAAG,EAAE,CAAA;IAEjC,IAAI,UAAU,GAAG,KAAK,CAAC,QAAQ,CAAA;IAE/B,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,sBAAsB,EAAE,CAAC;QACnD,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CACtB,yBAAyB,KAAK,CAAC,QAAQ,UAAU,sBAAsB,eAAe,KAAK,CAAC,QAAQ,CAAC,MAAM,cAAc,CAC1H,CAAA;QACD,UAAU,GAAG,QAAQ,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAA;IACvD,CAAC;IAED,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC;QAC3C,OAAO;QACP,SAAS,EAAE,KAAK,CAAC,aAAa;QAC9B,QAAQ,EAAE,UAAU;KACrB,CAAC,CAAA;IAEF,OAAO,YAAY,CAA0B;QAC3C,OAAO;QACP,QAAQ,EAAE;YACR,IAAI,EAAE,MAAM;YACZ,GAAG;YACH,SAAS;YACT,QAAQ,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,iBAAiB,CAAC,KAAK,CAAC,QAAQ,CAAC;YACrD,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;YAC5C,eAAe,EAAE;gBACf,QAAQ,EAAE,UAAU;gBACpB,aAAa,EAAE,KAAK,CAAC,aAAa;gBAClC,YAAY,EAAE,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC;aAC9C;SACF;KACF,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../src/browser/mod.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAA;AAItD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAEnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C,cAAc,yBAAyB,CAAA;AA+CvC,MAAM,CAAC,MAAM,eAAe,GAC1B,CAAC,EAAE,OAAO,EAA0B,EAAmB,EAAE,CACzD,CAAC,KAAuB,EAAE,EAAE,CAC1B,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;QAC/B,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,OAAO,CAAC,CAAA;QAClD,OAAO,YAAY,CAA8B;YAC/C,OAAO;YACP,QAAQ,EAAE;gBACR,IAAI,EAAE,WAAW;gBACjB,GAAG;gBACH,SAAS;gBACT,QAAQ,EAAE,GAAG,EAAE,GAAE,CAAC;gBAClB,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;gBAC5C,eAAe,EAAE;oBACf,QAAQ,EAAE,UAAU;iBACrB;aACF;SACF,CAAQ,CAAA;IACX,CAAC;IAED,wCAAwC;IACxC,MAAM,sBAAsB,GAAG,EAAE,CAAA;IAEjC,IAAI,UAAU,GAAG,KAAK,CAAC,QAAQ,CAAA;IAE/B,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,sBAAsB,EAAE,CAAC;QACnD,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CACtB,yBAAyB,KAAK,CAAC,QAAQ,UAAU,sBAAsB,eAAe,KAAK,CAAC,QAAQ,CAAC,MAAM,cAAc,CAC1H,CAAA;QACD,UAAU,GAAG,QAAQ,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAA;IACvD,CAAC;IAED,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC;QAC3C,OAAO;QACP,SAAS,EAAE,KAAK,CAAC,aAAa;QAC9B,QAAQ,EAAE,UAAU;KACrB,CAAC,CAAA;IAEF,OAAO,YAAY,CAA0B;QAC3C,OAAO;QACP,QAAQ,EAAE;YACR,IAAI,EAAE,MAAM;YACZ,GAAG;YACH,SAAS;YACT,QAAQ,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,iBAAiB,CAAC,KAAK,CAAC,QAAQ,CAAC;YACrD,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;YAC5C,eAAe,EAAE;gBACf,QAAQ,EAAE,UAAU;gBACpB,aAAa,EAAE,KAAK,CAAC,aAAa;gBAClC,YAAY,EAAE,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC;aAC9C;SACF;KACF,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/dist/cf/BlockManager.d.ts

@@ -0,0 +1,61 @@
+import type { CfTypes } from '@livestore/common-cf';
+export interface BlockRange {
+    startBlock: number;
+    endBlock: number;
+    startOffset: number;
+    endOffset: number;
+}
+export interface BlockData {
+    blockId: number;
+    data: Uint8Array;
+}
+/**
+ * BlockManager handles the conversion between file operations and block-based storage
+ * for the CloudflareSqlVFS. It manages fixed-size blocks stored in SQL tables.
+ */
+export declare class BlockManager {
+    private readonly blockSize;
+    constructor(blockSize?: number);
+    /**
+     * Calculate which blocks are needed for a given file operation
+     */
+    calculateBlockRange(offset: number, length: number): BlockRange;
+    /**
+     * Read blocks from SQL storage and return as a Map
+     */
+    readBlocks(sql: CfTypes.SqlStorage, filePath: string, blockIds: number[]): Map<number, Uint8Array>;
+    /**
+     * Write blocks to SQL storage using exec for now (prepared statements later)
+     */
+    writeBlocks(sql: CfTypes.SqlStorage, filePath: string, blocks: Map<number, Uint8Array>): void;
+    /**
+     * Delete blocks at or after the specified block ID (used for truncation)
+     */
+    deleteBlocksAfter(sql: CfTypes.SqlStorage, filePath: string, startBlockId: number): void;
+    /**
+     * Split write data into blocks, handling partial blocks at boundaries
+     */
+    splitIntoBlocks(data: Uint8Array, offset: number): Map<number, {
+        blockId: number;
+        blockOffset: number;
+        data: Uint8Array;
+    }>;
+    /**
+     * Assemble read data from blocks into a continuous buffer
+     */
+    assembleBlocks(blocks: Map<number, Uint8Array>, range: BlockRange, requestedLength: number): Uint8Array;
+    /**
+     * Handle partial block writes by reading existing block, modifying, and returning complete block
+     */
+    mergePartialBlock(sql: CfTypes.SqlStorage, filePath: string, blockId: number, blockOffset: number, newData: Uint8Array): Uint8Array;
+    /**
+     * Get statistics about block usage for a file
+     */
+    getBlockStats(sql: CfTypes.SqlStorage, filePath: string): {
+        totalBlocks: number;
+        storedBlocks: number;
+        totalBytes: number;
+    };
+    getBlockSize(): number;
+}
+//# sourceMappingURL=BlockManager.d.ts.map

package/dist/cf/BlockManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockManager.d.ts","sourceRoot":"","sources":["../../src/cf/BlockManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAEnD,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,UAAU,CAAA;CACjB;AAED;;;GAGG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;gBAEtB,SAAS,GAAE,MAAkB;IAIzC;;OAEG;IACH,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU;IAc/D;;OAEG;IACH,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC;IAyBlG;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,IAAI;IAe7F;;OAEG;IACH,iBAAiB,CAAC,GAAG,EAAE,OAAO,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAIxF;;OAEG;IACH,eAAe,CACb,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,GACb,GAAG,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC;IAyB1E;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,GAAG,UAAU;IA6BvG;;OAEG;IACH,iBAAiB,CACf,GAAG,EAAE,OAAO,CAAC,UAAU,EACvB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,UAAU,GAClB,UAAU;IAab;;OAEG;IACH,aAAa,CACX,GAAG,EAAE,OAAO,CAAC,UAAU,EACvB,QAAQ,EAAE,MAAM,GACf;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE;IAmCpE,YAAY,IAAI,MAAM;CAGvB"}

package/dist/cf/BlockManager.js

@@ -0,0 +1,157 @@
+/**
+ * BlockManager handles the conversion between file operations and block-based storage
+ * for the CloudflareSqlVFS. It manages fixed-size blocks stored in SQL tables.
+ */
+export class BlockManager {
+    blockSize;
+    constructor(blockSize = 64 * 1024) {
+        this.blockSize = blockSize;
+    }
+    /**
+     * Calculate which blocks are needed for a given file operation
+     */
+    calculateBlockRange(offset, length) {
+        const startBlock = Math.floor(offset / this.blockSize);
+        const endBlock = Math.floor((offset + length - 1) / this.blockSize);
+        const startOffset = offset % this.blockSize;
+        const endOffset = ((offset + length - 1) % this.blockSize) + 1;
+        return {
+            startBlock,
+            endBlock,
+            startOffset,
+            endOffset,
+        };
+    }
+    /**
+     * Read blocks from SQL storage and return as a Map
+     */
+    readBlocks(sql, filePath, blockIds) {
+        const blocks = new Map();
+        if (blockIds.length === 0) {
+            return blocks;
+        }
+        // Build IN clause for efficient querying
+        const placeholders = blockIds.map(() => '?').join(',');
+        const query = `
+      SELECT block_id, block_data 
+      FROM vfs_blocks 
+      WHERE file_path = ? AND block_id IN (${placeholders})
+      ORDER BY block_id
+    `;
+        const cursor = sql.exec(query, filePath, ...blockIds);
+        for (const row of cursor) {
+            blocks.set(row.block_id, new Uint8Array(row.block_data));
+        }
+        return blocks;
+    }
+    /**
+     * Write blocks to SQL storage using exec for now (prepared statements later)
+     */
+    writeBlocks(sql, filePath, blocks) {
+        if (blocks.size === 0) {
+            return;
+        }
+        for (const [blockId, data] of blocks) {
+            sql.exec('INSERT OR REPLACE INTO vfs_blocks (file_path, block_id, block_data) VALUES (?, ?, ?)', filePath, blockId, data);
+        }
+    }
+    /**
+     * Delete blocks at or after the specified block ID (used for truncation)
+     */
+    deleteBlocksAfter(sql, filePath, startBlockId) {
+        sql.exec('DELETE FROM vfs_blocks WHERE file_path = ? AND block_id >= ?', filePath, startBlockId);
+    }
+    /**
+     * Split write data into blocks, handling partial blocks at boundaries
+     */
+    splitIntoBlocks(data, offset) {
+        const blocks = new Map();
+        let remainingData = data;
+        let currentOffset = offset;
+        while (remainingData.length > 0) {
+            const blockId = Math.floor(currentOffset / this.blockSize);
+            const blockOffset = currentOffset % this.blockSize;
+            const bytesToWrite = Math.min(remainingData.length, this.blockSize - blockOffset);
+            const blockData = remainingData.slice(0, bytesToWrite);
+            blocks.set(blockId, {
+                blockId,
+                blockOffset,
+                data: blockData,
+            });
+            remainingData = remainingData.slice(bytesToWrite);
+            currentOffset += bytesToWrite;
+        }
+        return blocks;
+    }
+    /**
+     * Assemble read data from blocks into a continuous buffer
+     */
+    assembleBlocks(blocks, range, requestedLength) {
+        const result = new Uint8Array(requestedLength);
+        let resultOffset = 0;
+        for (let blockId = range.startBlock; blockId <= range.endBlock; blockId++) {
+            const blockData = blocks.get(blockId);
+            if (!blockData) {
+                // Block not found - fill with zeros (sparse file behavior)
+                const zeroLength = Math.min(this.blockSize, requestedLength - resultOffset);
+                // result is already zero-filled by default
+                resultOffset += zeroLength;
+                continue;
+            }
+            // Calculate the slice of this block we need
+            const blockStartOffset = blockId === range.startBlock ? range.startOffset : 0;
+            const blockEndOffset = blockId === range.endBlock ? range.endOffset : blockData.length;
+            const sliceLength = blockEndOffset - blockStartOffset;
+            if (sliceLength > 0) {
+                const slice = blockData.slice(blockStartOffset, blockEndOffset);
+                result.set(slice, resultOffset);
+                resultOffset += sliceLength;
+            }
+        }
+        return result;
+    }
+    /**
+     * Handle partial block writes by reading existing block, modifying, and returning complete block
+     */
+    mergePartialBlock(sql, filePath, blockId, blockOffset, newData) {
+        // Read existing block data if it exists
+        const existingBlocks = this.readBlocks(sql, filePath, [blockId]);
+        const existingBlock = existingBlocks.get(blockId) || new Uint8Array(this.blockSize);
+        // Create a new block with the merged data
+        const mergedBlock = new Uint8Array(this.blockSize);
+        mergedBlock.set(existingBlock);
+        mergedBlock.set(newData, blockOffset);
+        return mergedBlock;
+    }
+    /**
+     * Get statistics about block usage for a file
+     */
+    getBlockStats(sql, filePath) {
+        const blockStatsCursor = sql.exec(`SELECT 
+        COUNT(*) as stored_blocks,
+        COALESCE(SUM(LENGTH(block_data)), 0) as total_bytes
+      FROM vfs_blocks 
+      WHERE file_path = ?`, filePath);
+        const result = blockStatsCursor.one();
+        // Get file size to calculate theoretical total blocks
+        const fileSizeCursor = sql.exec('SELECT file_size FROM vfs_files WHERE file_path = ?', filePath);
+        let fileSize = 0;
+        try {
+            const fileSizeResult = fileSizeCursor.one();
+            fileSize = fileSizeResult.file_size;
+        }
+        catch {
+            // File doesn't exist
+        }
+        const totalBlocks = Math.ceil(fileSize / this.blockSize);
+        return {
+            totalBlocks,
+            storedBlocks: result.stored_blocks,
+            totalBytes: result.total_bytes,
+        };
+    }
+    getBlockSize() {
+        return this.blockSize;
+    }
+}
+//# sourceMappingURL=BlockManager.js.map

package/dist/cf/BlockManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockManager.js","sourceRoot":"","sources":["../../src/cf/BlockManager.ts"],"names":[],"mappings":"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"}

package/dist/cf/CloudflareSqlVFS.d.ts

@@ -0,0 +1,51 @@
+import type { CfTypes } from '@livestore/common-cf';
+import { FacadeVFS } from '../FacadeVFS.ts';
+export interface SqlVfsOptions {
+    maxFiles?: number;
+    blockSize?: number;
+}
+/**
+ * VFS implementation using Cloudflare Durable Object SQL storage as the backend.
+ * This provides a synchronous VFS interface by leveraging SQL's synchronous API.
+ *
+ * Storage Strategy:
+ * - Files are stored as blocks in SQL tables for efficient I/O
+ * - File metadata stored in vfs_files table
+ * - File data stored as fixed-size blocks in vfs_blocks table
+ * - Synchronous operations via SQL's synchronous API
+ *
+ * Key advantages over async VFS:
+ * - No async/await complexity
+ * - Native SQL ACID properties
+ * - Efficient range queries for file operations
+ * - Built-in consistency and durability
+ */
+export declare class CloudflareSqlVFS extends FacadeVFS {
+    #private;
+    log: null;
+    static create(name: string, sql: CfTypes.SqlStorage, module: any, options?: SqlVfsOptions): Promise<CloudflareSqlVFS>;
+    constructor(name: string, sql: CfTypes.SqlStorage, module: any, options?: SqlVfsOptions);
+    /**
+     * Initialize the VFS by setting up SQL schema
+     */
+    isReady(): Promise<boolean>;
+    jOpen(path: string, fileId: number, flags: number, pOutFlags: DataView): number;
+    jClose(fileId: number): number;
+    jRead(fileId: number, buffer: Uint8Array, offset: number): number;
+    jWrite(fileId: number, data: Uint8Array, offset: number): number;
+    jTruncate(fileId: number, size: number): number;
+    jSync(fileId: number, _flags: number): number;
+    jFileSize(fileId: number, pSize64: DataView): number;
+    jDelete(path: string, _syncDir: number): number;
+    jAccess(path: string, _flags: number, pResOut: DataView): number;
+    jSectorSize(_fileId: number): number;
+    jDeviceCharacteristics(_fileId: number): number;
+    getStats(): {
+        activeFiles: number;
+        openFiles: number;
+        maxFiles: number;
+        blockSize: number;
+        totalStoredBytes: number;
+    };
+}
+//# sourceMappingURL=CloudflareSqlVFS.d.ts.map

package/dist/cf/CloudflareSqlVFS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudflareSqlVFS.d.ts","sourceRoot":"","sources":["../../src/cf/CloudflareSqlVFS.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAEnD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AA6B3C,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;;IAC7C,GAAG,OAAO;WAUG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAE,aAAkB;gBAMvF,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAE,aAAkB;IAO3F;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IA2FjC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,GAAG,MAAM;IAqD/E,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAK9B,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAwBjE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAgDhE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAuC/C,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAS7C,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,MAAM;IAepD,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAU/C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,MAAM;IAWhE,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIpC,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IA+B/C,QAAQ,IAAI;QACV,WAAW,EAAE,MAAM,CAAA;QACnB,SAAS,EAAE,MAAM,CAAA;QACjB,QAAQ,EAAE,MAAM,CAAA;QAChB,SAAS,EAAE,MAAM,CAAA;QACjB,gBAAgB,EAAE,MAAM,CAAA;KACzB;CAwBF"}

package/dist/cf/CloudflareSqlVFS.js

@@ -0,0 +1,351 @@
+import * as VFS from '@livestore/wa-sqlite/src/VFS.js';
+import { FacadeVFS } from "../FacadeVFS.js";
+import { BlockManager } from "./BlockManager.js";
+const SECTOR_SIZE = 4096;
+// Block size for SQL-based storage (same as CloudflareWorkerVFS for consistency)
+const BLOCK_SIZE = 64 * 1024; // 64 KiB
+// Maximum number of open files
+const DEFAULT_MAX_FILES = 100;
+// These file types are expected to persist in the file system
+const PERSISTENT_FILE_TYPES = VFS.SQLITE_OPEN_MAIN_DB | VFS.SQLITE_OPEN_MAIN_JOURNAL | VFS.SQLITE_OPEN_SUPER_JOURNAL | VFS.SQLITE_OPEN_WAL;
+/**
+ * VFS implementation using Cloudflare Durable Object SQL storage as the backend.
+ * This provides a synchronous VFS interface by leveraging SQL's synchronous API.
+ *
+ * Storage Strategy:
+ * - Files are stored as blocks in SQL tables for efficient I/O
+ * - File metadata stored in vfs_files table
+ * - File data stored as fixed-size blocks in vfs_blocks table
+ * - Synchronous operations via SQL's synchronous API
+ *
+ * Key advantages over async VFS:
+ * - No async/await complexity
+ * - Native SQL ACID properties
+ * - Efficient range queries for file operations
+ * - Built-in consistency and durability
+ */
+export class CloudflareSqlVFS extends FacadeVFS {
+    log = null;
+    #sql;
+    #initialized = false;
+    #blockManager;
+    // File management
+    #openFiles = new Map();
+    #maxFiles;
+    static async create(name, sql, module, options = {}) {
+        const vfs = new CloudflareSqlVFS(name, sql, module, options);
+        await vfs.isReady();
+        return vfs;
+    }
+    constructor(name, sql, module, options = {}) {
+        super(name, module);
+        this.#sql = sql;
+        this.#maxFiles = options.maxFiles || DEFAULT_MAX_FILES;
+        this.#blockManager = new BlockManager(options.blockSize || BLOCK_SIZE);
+    }
+    /**
+     * Initialize the VFS by setting up SQL schema
+     */
+    async isReady() {
+        if (this.#initialized) {
+            return true;
+        }
+        try {
+            // Initialize SQL schema
+            this.#initializeSchema();
+            // Clean up non-persistent files from previous sessions
+            this.#cleanupNonPersistentFiles();
+            this.#initialized = true;
+            return true;
+        }
+        catch (error) {
+            console.error('CloudflareSqlVFS initialization failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Initialize the SQL schema for the VFS
+     */
+    #initializeSchema() {
+        // Execute each statement individually to avoid parsing issues
+        const statements = [
+            `CREATE TABLE IF NOT EXISTS vfs_files (
+        file_path TEXT PRIMARY KEY,
+        file_size INTEGER NOT NULL DEFAULT 0,
+        flags INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        modified_at INTEGER NOT NULL DEFAULT (unixepoch())
+      )`,
+            `CREATE TABLE IF NOT EXISTS vfs_blocks (
+        file_path TEXT NOT NULL,
+        block_id INTEGER NOT NULL,
+        block_data BLOB NOT NULL,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        PRIMARY KEY (file_path, block_id),
+        FOREIGN KEY (file_path) REFERENCES vfs_files(file_path) ON DELETE CASCADE
+      )`,
+            `CREATE INDEX IF NOT EXISTS idx_vfs_blocks_range ON vfs_blocks(file_path, block_id)`,
+            `CREATE INDEX IF NOT EXISTS idx_vfs_files_modified ON vfs_files(modified_at)`,
+            `CREATE TRIGGER IF NOT EXISTS trg_vfs_files_update_modified 
+        AFTER UPDATE OF file_size ON vfs_files
+        BEGIN
+          UPDATE vfs_files SET modified_at = unixepoch() WHERE file_path = NEW.file_path;
+        END`,
+        ];
+        for (const statement of statements) {
+            try {
+                this.#sql.exec(statement);
+            }
+            catch (error) {
+                console.error('Failed to execute schema statement:', statement);
+                throw error;
+            }
+        }
+    }
+    /**
+     * Clean up non-persistent files from previous sessions
+     */
+    #cleanupNonPersistentFiles() {
+        try {
+            const cursor = this.#sql.exec('SELECT file_path, flags FROM vfs_files');
+            const filesToDelete = [];
+            for (const row of cursor) {
+                // Check if file should be persistent
+                if (!(row.flags & PERSISTENT_FILE_TYPES)) {
+                    filesToDelete.push(row.file_path);
+                }
+            }
+            // Delete non-persistent files
+            for (const filePath of filesToDelete) {
+                this.#sql.exec('DELETE FROM vfs_files WHERE file_path = ?', filePath);
+            }
+        }
+        catch (error) {
+            console.warn('Error during cleanup:', error);
+        }
+    }
+    // VFS Interface Implementation
+    jOpen(path, fileId, flags, pOutFlags) {
+        try {
+            if (this.#openFiles.size >= this.#maxFiles) {
+                return VFS.SQLITE_CANTOPEN;
+            }
+            // Check if file exists
+            const existingFile = this.#getFileMetadata(path);
+            if (!existingFile && !(flags & VFS.SQLITE_OPEN_CREATE)) {
+                return VFS.SQLITE_CANTOPEN;
+            }
+            let metadata;
+            if (existingFile) {
+                metadata = existingFile;
+            }
+            else {
+                // Create new file
+                const now = Math.floor(Date.now() / 1000);
+                metadata = {
+                    path,
+                    size: 0,
+                    flags,
+                    created: now,
+                    modified: now,
+                };
+                this.#sql.exec('INSERT INTO vfs_files (file_path, file_size, flags, created_at, modified_at) VALUES (?, ?, ?, ?, ?)', path, 0, flags, now, now);
+            }
+            // Store file handle
+            this.#openFiles.set(fileId, {
+                path,
+                flags,
+                metadata,
+            });
+            pOutFlags.setInt32(0, flags, true);
+            return VFS.SQLITE_OK;
+        }
+        catch (error) {
+            console.error('jOpen error:', error);
+            return VFS.SQLITE_CANTOPEN;
+        }
+    }
+    jClose(fileId) {
+        this.#openFiles.delete(fileId);
+        return VFS.SQLITE_OK;
+    }
+    jRead(fileId, buffer, offset) {
+        try {
+            const handle = this.#openFiles.get(fileId);
+            if (!handle) {
+                return VFS.SQLITE_IOERR;
+            }
+            const range = this.#blockManager.calculateBlockRange(offset, buffer.length);
+            const blockIds = [];
+            for (let i = range.startBlock; i <= range.endBlock; i++) {
+                blockIds.push(i);
+            }
+            const blocks = this.#blockManager.readBlocks(this.#sql, handle.path, blockIds);
+            const data = this.#blockManager.assembleBlocks(blocks, range, buffer.length);
+            buffer.set(data);
+            return VFS.SQLITE_OK;
+        }
+        catch (error) {
+            console.error('jRead error:', error);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jWrite(fileId, data, offset) {
+        try {
+            const handle = this.#openFiles.get(fileId);
+            if (!handle) {
+                return VFS.SQLITE_IOERR;
+            }
+            // Split write data into blocks
+            const writeBlocks = this.#blockManager.splitIntoBlocks(data, offset);
+            const finalBlocks = new Map();
+            for (const [blockId, blockInfo] of writeBlocks) {
+                let blockData;
+                if (blockInfo.blockOffset === 0 && blockInfo.data.length === this.#blockManager.getBlockSize()) {
+                    // Full block write
+                    blockData = blockInfo.data;
+                }
+                else {
+                    // Partial block write - merge with existing data
+                    blockData = this.#blockManager.mergePartialBlock(this.#sql, handle.path, blockInfo.blockId, blockInfo.blockOffset, blockInfo.data);
+                }
+                finalBlocks.set(blockId, blockData);
+            }
+            // Write blocks to SQL storage
+            this.#blockManager.writeBlocks(this.#sql, handle.path, finalBlocks);
+            // Update file size if necessary
+            const newSize = Math.max(handle.metadata.size, offset + data.length);
+            if (newSize !== handle.metadata.size) {
+                this.#sql.exec('UPDATE vfs_files SET file_size = ? WHERE file_path = ?', newSize, handle.path);
+                handle.metadata.size = newSize;
+            }
+            return VFS.SQLITE_OK;
+        }
+        catch (error) {
+            console.error('jWrite error:', error);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jTruncate(fileId, size) {
+        try {
+            const handle = this.#openFiles.get(fileId);
+            if (!handle) {
+                return VFS.SQLITE_IOERR;
+            }
+            // Calculate which block contains the new end of file
+            const lastBlockId = Math.floor(size / this.#blockManager.getBlockSize());
+            // Delete blocks beyond the truncation point
+            this.#blockManager.deleteBlocksAfter(this.#sql, handle.path, lastBlockId + 1);
+            // If truncating within a block, we need to truncate that block's data
+            if (size % this.#blockManager.getBlockSize() !== 0) {
+                const existingBlocks = this.#blockManager.readBlocks(this.#sql, handle.path, [lastBlockId]);
+                const blockData = existingBlocks.get(lastBlockId);
+                if (blockData) {
+                    const truncatedBlock = blockData.slice(0, size % this.#blockManager.getBlockSize());
+                    const paddedBlock = new Uint8Array(this.#blockManager.getBlockSize());
+                    paddedBlock.set(truncatedBlock);
+                    const blocksToWrite = new Map([[lastBlockId, paddedBlock]]);
+                    this.#blockManager.writeBlocks(this.#sql, handle.path, blocksToWrite);
+                }
+            }
+            // Update file metadata
+            this.#sql.exec('UPDATE vfs_files SET file_size = ? WHERE file_path = ?', size, handle.path);
+            handle.metadata.size = size;
+            return VFS.SQLITE_OK;
+        }
+        catch (error) {
+            console.error('jTruncate error:', error);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jSync(fileId, _flags) {
+        // SQL storage provides immediate durability, so sync is effectively a no-op
+        const handle = this.#openFiles.get(fileId);
+        if (!handle) {
+            return VFS.SQLITE_IOERR;
+        }
+        return VFS.SQLITE_OK;
+    }
+    jFileSize(fileId, pSize64) {
+        try {
+            const handle = this.#openFiles.get(fileId);
+            if (!handle) {
+                return VFS.SQLITE_IOERR;
+            }
+            pSize64.setBigInt64(0, BigInt(handle.metadata.size), true);
+            return VFS.SQLITE_OK;
+        }
+        catch (error) {
+            console.error('jFileSize error:', error);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jDelete(path, _syncDir) {
+        try {
+            this.#sql.exec('DELETE FROM vfs_files WHERE file_path = ?', path);
+            return VFS.SQLITE_OK;
+        }
+        catch (error) {
+            console.error('jDelete error:', error);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jAccess(path, _flags, pResOut) {
+        try {
+            const metadata = this.#getFileMetadata(path);
+            pResOut.setInt32(0, metadata ? 1 : 0, true);
+            return VFS.SQLITE_OK;
+        }
+        catch (error) {
+            console.error('jAccess error:', error);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jSectorSize(_fileId) {
+        return SECTOR_SIZE;
+    }
+    jDeviceCharacteristics(_fileId) {
+        return VFS.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
+    }
+    // Helper methods
+    #getFileMetadata(path) {
+        try {
+            const cursor = this.#sql.exec('SELECT file_path, file_size, flags, created_at, modified_at FROM vfs_files WHERE file_path = ?', path);
+            const row = cursor.one();
+            return {
+                path: row.file_path,
+                size: row.file_size,
+                flags: row.flags,
+                created: row.created_at,
+                modified: row.modified_at,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // Statistics and debugging
+    getStats() {
+        try {
+            const cursor = this.#sql.exec('SELECT COUNT(*) as total_files, COALESCE(SUM(LENGTH(block_data)), 0) as total_bytes FROM vfs_files LEFT JOIN vfs_blocks USING (file_path)');
+            const stats = cursor.one();
+            return {
+                activeFiles: stats.total_files,
+                openFiles: this.#openFiles.size,
+                maxFiles: this.#maxFiles,
+                blockSize: this.#blockManager.getBlockSize(),
+                totalStoredBytes: stats.total_bytes,
+            };
+        }
+        catch {
+            return {
+                activeFiles: 0,
+                openFiles: this.#openFiles.size,
+                maxFiles: this.#maxFiles,
+                blockSize: this.#blockManager.getBlockSize(),
+                totalStoredBytes: 0,
+            };
+        }
+    }
+}
+//# sourceMappingURL=CloudflareSqlVFS.js.map