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

package/dist/cf/CloudflareSqlVFS.js.map

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

package/dist/cf/CloudflareWorkerVFS.d.ts

@@ -0,0 +1,72 @@
+import type { CfTypes } from '@livestore/common-cf';
+import { FacadeVFS } from '../FacadeVFS.ts';
+/**
+ * VFS implementation using Cloudflare DurableObjectStorage as the backend.
+ * Uses chunked storage with in-memory caching for synchronous operations.
+ *
+ * Storage Strategy:
+ * - Files are split into 64 KiB chunks for optimal SQLite I/O patterns
+ * - Metadata cached in memory for synchronous access
+ * - LRU cache for frequently accessed chunks
+ *
+ * Key Schema:
+ * - file:${path}:meta - File metadata (size, flags, chunkCount, created)
+ * - file:${path}:${chunkIndex} - File data chunks (64 KiB max)
+ * - index:files - Set of active file paths
+ */
+export declare class CloudflareWorkerVFS extends FacadeVFS {
+    #private;
+    log: null;
+    static create(name: string, storage: CfTypes.DurableObjectStorage, module: any): Promise<CloudflareWorkerVFS>;
+    constructor(name: string, storage: CfTypes.DurableObjectStorage, module: any);
+    jOpen(zName: string, fileId: number, flags: number, pOutFlags: DataView): number;
+    jClose(fileId: number): number;
+    jRead(fileId: number, pData: Uint8Array, iOffset: number): number;
+    jWrite(fileId: number, pData: Uint8Array, iOffset: number): number;
+    jTruncate(fileId: number, iSize: number): number;
+    jSync(fileId: number, _flags: number): number;
+    jFileSize(fileId: number, pSize64: DataView): number;
+    jSectorSize(_fileId: number): number;
+    jDeviceCharacteristics(_fileId: number): number;
+    jAccess(zName: string, _flags: number, pResOut: DataView): number;
+    jDelete(zName: string, _syncDir: number): number;
+    close(): Promise<void>;
+    isReady(): Promise<boolean>;
+    /**
+     * Returns the number of SQLite files in the file system.
+     */
+    getSize(): number;
+    /**
+     * Returns the maximum number of SQLite files the file system can hold.
+     */
+    getCapacity(): number;
+    /**
+     * Increase the capacity of the file system by n.
+     */
+    addCapacity(n: number): Promise<number>;
+    /**
+     * Decrease the capacity of the file system by n. The capacity cannot be
+     * decreased to fewer than the current number of SQLite files in the
+     * file system.
+     */
+    removeCapacity(n: number): Promise<number>;
+    /**
+     * Flush all pending writes and sync to storage.
+     * This is useful for ensuring durability before critical operations.
+     */
+    syncToStorage(): Promise<void>;
+    /**
+     * Get statistics about the VFS for debugging and monitoring.
+     */
+    getStats(): {
+        activeFiles: number;
+        openFiles: number;
+        cachedChunks: number;
+        cachedMetadata: number;
+        pendingWrites: number;
+        maxFiles: number;
+        maxCacheSize: number;
+        chunkSize: number;
+    };
+}
+//# sourceMappingURL=CloudflareWorkerVFS.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CloudflareWorkerVFS.d.ts","sourceRoot":"","sources":["../../src/cf/CloudflareWorkerVFS.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAEnD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAoC3C;;;;;;;;;;;;;GAaG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;;IAChD,GAAG,OAAO;WAeG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,oBAAoB,EAAE,MAAM,EAAE,GAAG;gBAMxE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,oBAAoB,EAAE,MAAM,EAAE,GAAG;IAoJ5E,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,GAAG,MAAM;IA6ChF,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAY9B,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IA6DjE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IA6DlE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAuDhD,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAe7C,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,MAAM;IAapD,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIpC,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAI/C,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,MAAM;IAYjE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAc1C,KAAK;IASL,OAAO;IAyCb;;OAEG;IACH,OAAO,IAAI,MAAM;IAIjB;;OAEG;IACH,WAAW,IAAI,MAAM;IAIrB;;OAEG;IACG,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK7C;;;;OAIG;IACG,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAoChD;;;OAGG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAKpC;;OAEG;IACH,QAAQ;;;;;;;;;;CAoBT"}

package/dist/cf/CloudflareWorkerVFS.js

@@ -0,0 +1,552 @@
+import * as VFS from '@livestore/wa-sqlite/src/VFS.js';
+import { FacadeVFS } from "../FacadeVFS.js";
+const SECTOR_SIZE = 4096;
+// Chunk size optimized for SQLite I/O patterns
+// 64 KiB provides good balance between memory usage and I/O efficiency
+// while staying well under DurableObjectStorage's 128 KiB limit
+const CHUNK_SIZE = 64 * 1024; // 64 KiB
+// Cache configuration for synchronous operations
+const DEFAULT_CACHE_SIZE = 10; // Number of chunks to cache
+const DEFAULT_MAX_FILES = 100; // Maximum number of files
+// These file types are expected to persist in the file system outside
+// a session. Other files will be removed on VFS start.
+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 DurableObjectStorage as the backend.
+ * Uses chunked storage with in-memory caching for synchronous operations.
+ *
+ * Storage Strategy:
+ * - Files are split into 64 KiB chunks for optimal SQLite I/O patterns
+ * - Metadata cached in memory for synchronous access
+ * - LRU cache for frequently accessed chunks
+ *
+ * Key Schema:
+ * - file:${path}:meta - File metadata (size, flags, chunkCount, created)
+ * - file:${path}:${chunkIndex} - File data chunks (64 KiB max)
+ * - index:files - Set of active file paths
+ */
+export class CloudflareWorkerVFS extends FacadeVFS {
+    log = null;
+    #storage;
+    #initialized = false;
+    // In-memory caches for synchronous operations
+    #metadataCache = new Map();
+    #chunkCache = new Map();
+    #activeFiles = new Set();
+    #openFiles = new Map();
+    // Configuration
+    #maxCacheSize;
+    #maxFiles;
+    static async create(name, storage, module) {
+        const vfs = new CloudflareWorkerVFS(name, storage, module);
+        await vfs.isReady();
+        return vfs;
+    }
+    constructor(name, storage, module) {
+        super(name, module);
+        this.#storage = storage;
+        this.#maxCacheSize = DEFAULT_CACHE_SIZE;
+        this.#maxFiles = DEFAULT_MAX_FILES;
+    }
+    // Storage key generation helpers
+    #getMetadataKey(path) {
+        return `file:${path}:meta`;
+    }
+    #getChunkKey(path, chunkIndex) {
+        return `file:${path}:${chunkIndex}`;
+    }
+    #getCacheKey(path, chunkIndex) {
+        return `${path}:${chunkIndex}`;
+    }
+    // Cache management
+    #evictLRUChunk() {
+        if (this.#chunkCache.size < this.#maxCacheSize)
+            return;
+        let oldestKey = '';
+        let oldestTime = Date.now();
+        for (const [key, entry] of this.#chunkCache) {
+            if (entry.lastAccessed < oldestTime) {
+                oldestTime = entry.lastAccessed;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.#chunkCache.delete(oldestKey);
+        }
+    }
+    #getCachedChunk(path, chunkIndex) {
+        const key = this.#getCacheKey(path, chunkIndex);
+        const entry = this.#chunkCache.get(key);
+        if (entry) {
+            entry.lastAccessed = Date.now();
+            return entry.data;
+        }
+        return undefined;
+    }
+    #setCachedChunk(path, chunkIndex, data) {
+        this.#evictLRUChunk();
+        const key = this.#getCacheKey(path, chunkIndex);
+        this.#chunkCache.set(key, {
+            data: data.slice(), // Copy the data
+            lastAccessed: Date.now(),
+        });
+    }
+    // Critical: Handle synchronous operations with async backend
+    // Strategy: Use aggressive caching + background sync for durability
+    // All reads must be served from cache, writes are cached immediately
+    // and synced to storage asynchronously
+    #pendingWrites = new Set();
+    #writePromises = new Map();
+    #scheduleWrite(path, operation) {
+        const key = `write:${path}`;
+        // Cancel any pending write for this path
+        if (this.#writePromises.has(key)) {
+            this.#pendingWrites.delete(key);
+        }
+        // Schedule new write
+        this.#pendingWrites.add(key);
+        const promise = operation().finally(() => {
+            this.#pendingWrites.delete(key);
+            this.#writePromises.delete(key);
+        });
+        this.#writePromises.set(key, promise);
+    }
+    async #flushPendingWrites() {
+        const promises = Array.from(this.#writePromises.values());
+        await Promise.all(promises);
+    }
+    async #loadMetadata(path) {
+        const cached = this.#metadataCache.get(path);
+        if (cached)
+            return cached;
+        const metadata = await this.#storage.get(this.#getMetadataKey(path));
+        if (metadata) {
+            this.#metadataCache.set(path, metadata);
+        }
+        return metadata;
+    }
+    async #saveMetadata(path, metadata) {
+        // TODO: Consider allowUnconfirmed: true for better performance
+        // Currently using strict consistency as requested
+        // Future optimization: explore allowUnconfirmed for non-critical writes
+        await this.#storage.put(this.#getMetadataKey(path), metadata);
+        this.#metadataCache.set(path, metadata);
+    }
+    async #loadChunk(path, chunkIndex) {
+        const cached = this.#getCachedChunk(path, chunkIndex);
+        if (cached)
+            return cached;
+        const chunk = await this.#storage.get(this.#getChunkKey(path, chunkIndex));
+        if (chunk) {
+            this.#setCachedChunk(path, chunkIndex, chunk);
+        }
+        return chunk;
+    }
+    async #saveChunk(path, chunkIndex, data) {
+        await this.#storage.put(this.#getChunkKey(path, chunkIndex), data);
+        this.#setCachedChunk(path, chunkIndex, data);
+    }
+    async #deleteFile(path) {
+        const metadata = await this.#loadMetadata(path);
+        if (!metadata)
+            return;
+        // Delete all chunks and metadata atomically
+        const keysToDelete = [this.#getMetadataKey(path)];
+        for (let i = 0; i < metadata.chunkCount; i++) {
+            keysToDelete.push(this.#getChunkKey(path, i));
+        }
+        await this.#storage.delete(keysToDelete);
+        // Clean up caches
+        this.#metadataCache.delete(path);
+        for (let i = 0; i < metadata.chunkCount; i++) {
+            this.#chunkCache.delete(this.#getCacheKey(path, i));
+        }
+        this.#activeFiles.delete(path);
+        // Update the file index
+        await this.#updateFileIndex();
+    }
+    jOpen(zName, fileId, flags, pOutFlags) {
+        try {
+            const path = zName ? this.#getPath(zName) : Math.random().toString(36);
+            const metadata = this.#metadataCache.get(path);
+            if (!metadata && flags & VFS.SQLITE_OPEN_CREATE) {
+                // Create new file
+                if (this.#activeFiles.size >= this.#maxFiles) {
+                    throw new Error('cannot create file: capacity exceeded');
+                }
+                const newMetadata = {
+                    size: 0,
+                    flags,
+                    chunkCount: 0,
+                    created: Date.now(),
+                };
+                // Cache the metadata immediately for synchronous access
+                this.#metadataCache.set(path, newMetadata);
+                this.#activeFiles.add(path);
+                // Schedule async save to maintain durability
+                this.#scheduleWrite(path, () => this.#saveMetadata(path, newMetadata));
+            }
+            if (!this.#metadataCache.has(path)) {
+                throw new Error('file not found');
+            }
+            const handle = {
+                path,
+                flags,
+                metadata: this.#metadataCache.get(path),
+            };
+            this.#openFiles.set(fileId, handle);
+            pOutFlags.setInt32(0, flags, true);
+            return VFS.SQLITE_OK;
+        }
+        catch (e) {
+            console.error(e.message);
+            return VFS.SQLITE_CANTOPEN;
+        }
+    }
+    jClose(fileId) {
+        const handle = this.#openFiles.get(fileId);
+        if (handle) {
+            this.#openFiles.delete(fileId);
+            if (handle.flags & VFS.SQLITE_OPEN_DELETEONCLOSE) {
+                // Schedule async delete
+                this.#scheduleWrite(handle.path, () => this.#deleteFile(handle.path));
+            }
+        }
+        return VFS.SQLITE_OK;
+    }
+    jRead(fileId, pData, iOffset) {
+        try {
+            const handle = this.#openFiles.get(fileId);
+            if (!handle)
+                return VFS.SQLITE_IOERR;
+            const fileSize = handle.metadata.size;
+            const requestedBytes = pData.byteLength;
+            // Zero-length reads should always succeed
+            if (requestedBytes === 0) {
+                return VFS.SQLITE_OK;
+            }
+            if (iOffset >= fileSize) {
+                pData.fill(0);
+                return VFS.SQLITE_IOERR_SHORT_READ;
+            }
+            const bytesToRead = Math.min(requestedBytes, fileSize - iOffset);
+            const startChunk = Math.floor(iOffset / CHUNK_SIZE);
+            const endChunk = Math.floor((iOffset + bytesToRead - 1) / CHUNK_SIZE);
+            let bytesRead = 0;
+            for (let chunkIndex = startChunk; chunkIndex <= endChunk; chunkIndex++) {
+                const chunk = this.#getCachedChunk(handle.path, chunkIndex);
+                if (!chunk) {
+                    // Cache miss - this is a problem for synchronous operation
+                    // We should have preloaded chunks during initialization
+                    console.warn(`Cache miss for chunk ${chunkIndex} of ${handle.path}`);
+                    // Emergency: try to preload the chunk for future reads
+                    this.#preloadChunks(handle.path, chunkIndex, 1).catch(console.error);
+                    pData.fill(0, bytesRead);
+                    return VFS.SQLITE_IOERR_SHORT_READ;
+                }
+                const chunkOffset = chunkIndex * CHUNK_SIZE;
+                const readStart = Math.max(0, iOffset - chunkOffset);
+                const readEnd = Math.min(chunk.length, iOffset + requestedBytes - chunkOffset);
+                const chunkBytesToRead = readEnd - readStart;
+                if (chunkBytesToRead > 0) {
+                    pData.set(chunk.subarray(readStart, readEnd), bytesRead);
+                    bytesRead += chunkBytesToRead;
+                }
+            }
+            if (bytesRead < requestedBytes) {
+                pData.fill(0, bytesRead, requestedBytes);
+                return VFS.SQLITE_IOERR_SHORT_READ;
+            }
+            return VFS.SQLITE_OK;
+        }
+        catch (e) {
+            console.error('jRead error:', e.message);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jWrite(fileId, pData, iOffset) {
+        try {
+            const handle = this.#openFiles.get(fileId);
+            if (!handle)
+                return VFS.SQLITE_IOERR;
+            const bytesToWrite = pData.byteLength;
+            const startChunk = Math.floor(iOffset / CHUNK_SIZE);
+            const endChunk = Math.floor((iOffset + bytesToWrite - 1) / CHUNK_SIZE);
+            let bytesWritten = 0;
+            const chunksToSave = [];
+            for (let chunkIndex = startChunk; chunkIndex <= endChunk; chunkIndex++) {
+                const chunkOffset = chunkIndex * CHUNK_SIZE;
+                const writeStart = Math.max(0, iOffset - chunkOffset);
+                const writeEnd = Math.min(CHUNK_SIZE, iOffset + bytesToWrite - chunkOffset);
+                let chunk = this.#getCachedChunk(handle.path, chunkIndex);
+                if (!chunk) {
+                    // Create new chunk
+                    chunk = new Uint8Array(CHUNK_SIZE);
+                }
+                else {
+                    // Copy existing chunk for modification
+                    chunk = chunk.slice();
+                }
+                const chunkBytesToWrite = writeEnd - writeStart;
+                if (chunkBytesToWrite > 0) {
+                    const dataOffset = bytesWritten;
+                    chunk.set(pData.subarray(dataOffset, dataOffset + chunkBytesToWrite), writeStart);
+                    bytesWritten += chunkBytesToWrite;
+                    chunksToSave.push({ chunkIndex, data: chunk });
+                }
+            }
+            // Update metadata
+            const newSize = Math.max(handle.metadata.size, iOffset + bytesToWrite);
+            const newChunkCount = Math.ceil(newSize / CHUNK_SIZE);
+            handle.metadata.size = newSize;
+            handle.metadata.chunkCount = newChunkCount;
+            // Cache the modified chunks immediately
+            for (const { chunkIndex, data } of chunksToSave) {
+                this.#setCachedChunk(handle.path, chunkIndex, data);
+            }
+            // Schedule async saves to maintain durability
+            this.#scheduleWrite(handle.path, async () => {
+                await this.#saveMetadata(handle.path, handle.metadata);
+                await Promise.all(chunksToSave.map(({ chunkIndex, data }) => this.#saveChunk(handle.path, chunkIndex, data)));
+            });
+            return VFS.SQLITE_OK;
+        }
+        catch (e) {
+            console.error('jWrite error:', e.message);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jTruncate(fileId, iSize) {
+        try {
+            const handle = this.#openFiles.get(fileId);
+            if (!handle)
+                return VFS.SQLITE_IOERR;
+            // const oldSize = handle.metadata.size
+            const newChunkCount = Math.ceil(iSize / CHUNK_SIZE);
+            const oldChunkCount = handle.metadata.chunkCount;
+            handle.metadata.size = iSize;
+            handle.metadata.chunkCount = newChunkCount;
+            // If truncating to smaller size, remove excess chunks
+            if (newChunkCount < oldChunkCount) {
+                const chunksToDelete = [];
+                for (let i = newChunkCount; i < oldChunkCount; i++) {
+                    const cacheKey = this.#getCacheKey(handle.path, i);
+                    this.#chunkCache.delete(cacheKey);
+                    chunksToDelete.push(this.#getChunkKey(handle.path, i));
+                }
+                // Schedule async delete of excess chunks
+                if (chunksToDelete.length > 0) {
+                    this.#scheduleWrite(handle.path, async () => {
+                        await this.#storage.delete(chunksToDelete);
+                    });
+                }
+            }
+            // If the last chunk needs to be truncated, update it
+            if (newChunkCount > 0) {
+                const lastChunkIndex = newChunkCount - 1;
+                const lastChunkSize = iSize - lastChunkIndex * CHUNK_SIZE;
+                if (lastChunkSize < CHUNK_SIZE) {
+                    const lastChunk = this.#getCachedChunk(handle.path, lastChunkIndex);
+                    if (lastChunk) {
+                        const truncatedChunk = new Uint8Array(CHUNK_SIZE);
+                        truncatedChunk.set(lastChunk.subarray(0, lastChunkSize));
+                        this.#setCachedChunk(handle.path, lastChunkIndex, truncatedChunk);
+                        this.#scheduleWrite(handle.path, () => this.#saveChunk(handle.path, lastChunkIndex, truncatedChunk));
+                    }
+                }
+            }
+            // Schedule async metadata update
+            this.#scheduleWrite(handle.path, () => this.#saveMetadata(handle.path, handle.metadata));
+            return VFS.SQLITE_OK;
+        }
+        catch (e) {
+            console.error('jTruncate error:', e.message);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jSync(fileId, _flags) {
+        try {
+            const handle = this.#openFiles.get(fileId);
+            if (!handle)
+                return VFS.SQLITE_IOERR;
+            // Force sync all pending writes for this file
+            // Note: DurableObjectStorage operations are already synchronous
+            // and atomic, so this is mostly a no-op
+            return VFS.SQLITE_OK;
+        }
+        catch (e) {
+            console.error('jSync error:', e.message);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    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 (e) {
+            console.error('jFileSize error:', e.message);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jSectorSize(_fileId) {
+        return SECTOR_SIZE;
+    }
+    jDeviceCharacteristics(_fileId) {
+        return VFS.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
+    }
+    jAccess(zName, _flags, pResOut) {
+        try {
+            const path = this.#getPath(zName);
+            const exists = this.#activeFiles.has(path);
+            pResOut.setInt32(0, exists ? 1 : 0, true);
+            return VFS.SQLITE_OK;
+        }
+        catch (e) {
+            console.error('jAccess error:', e.message);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    jDelete(zName, _syncDir) {
+        try {
+            const path = this.#getPath(zName);
+            // Schedule async delete
+            this.#scheduleWrite(path, () => this.#deleteFile(path));
+            return VFS.SQLITE_OK;
+        }
+        catch (e) {
+            console.error('jDelete error:', e.message);
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    async close() {
+        // Clear all caches
+        this.#metadataCache.clear();
+        this.#chunkCache.clear();
+        this.#activeFiles.clear();
+        this.#openFiles.clear();
+        this.#initialized = false;
+    }
+    async isReady() {
+        if (!this.#initialized) {
+            await this.#initializeStorage();
+            this.#initialized = true;
+        }
+        return true;
+    }
+    async #initializeStorage() {
+        // Load list of existing files
+        const fileList = await this.#storage.get('index:files');
+        if (fileList) {
+            for (const path of fileList) {
+                this.#activeFiles.add(path);
+                // Preload metadata for all files
+                await this.#loadMetadata(path);
+                // Preload first chunk of each file for better performance
+                await this.#loadChunk(path, 0);
+            }
+        }
+        // Clean up temporary files that shouldn't persist
+        await this.#cleanupTemporaryFiles();
+        // Update the file index to reflect any cleanup
+        await this.#updateFileIndex();
+    }
+    async #cleanupTemporaryFiles() {
+        for (const path of this.#activeFiles) {
+            const metadata = this.#metadataCache.get(path);
+            if (metadata &&
+                (metadata.flags & VFS.SQLITE_OPEN_DELETEONCLOSE || (metadata.flags & PERSISTENT_FILE_TYPES) === 0)) {
+                console.warn(`Cleaning up temporary file: ${path}`);
+                await this.#deleteFile(path);
+            }
+        }
+    }
+    /**
+     * Returns the number of SQLite files in the file system.
+     */
+    getSize() {
+        return this.#activeFiles.size;
+    }
+    /**
+     * Returns the maximum number of SQLite files the file system can hold.
+     */
+    getCapacity() {
+        return this.#maxFiles;
+    }
+    /**
+     * Increase the capacity of the file system by n.
+     */
+    async addCapacity(n) {
+        this.#maxFiles += n;
+        return n;
+    }
+    /**
+     * Decrease the capacity of the file system by n. The capacity cannot be
+     * decreased to fewer than the current number of SQLite files in the
+     * file system.
+     */
+    async removeCapacity(n) {
+        const currentSize = this.getSize();
+        const currentCapacity = this.getCapacity();
+        const newCapacity = Math.max(currentSize, currentCapacity - n);
+        const actualReduction = currentCapacity - newCapacity;
+        this.#maxFiles = newCapacity;
+        return actualReduction;
+    }
+    async #updateFileIndex() {
+        // Update the persistent file index
+        const fileList = Array.from(this.#activeFiles);
+        await this.#storage.put('index:files', fileList);
+    }
+    /**
+     * Preload chunks for a file to support synchronous reads.
+     * SQLite typically reads files sequentially, so we preload nearby chunks.
+     */
+    async #preloadChunks(path, startChunk, count = 3) {
+        const metadata = this.#metadataCache.get(path);
+        if (!metadata)
+            return;
+        const endChunk = Math.min(startChunk + count, metadata.chunkCount);
+        const promises = [];
+        for (let i = startChunk; i < endChunk; i++) {
+            if (!this.#getCachedChunk(path, i)) {
+                promises.push(this.#loadChunk(path, i).then(() => { }));
+            }
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Flush all pending writes and sync to storage.
+     * This is useful for ensuring durability before critical operations.
+     */
+    async syncToStorage() {
+        await this.#flushPendingWrites();
+        await this.#storage.sync();
+    }
+    /**
+     * Get statistics about the VFS for debugging and monitoring.
+     */
+    getStats() {
+        return {
+            activeFiles: this.#activeFiles.size,
+            openFiles: this.#openFiles.size,
+            cachedChunks: this.#chunkCache.size,
+            cachedMetadata: this.#metadataCache.size,
+            pendingWrites: this.#pendingWrites.size,
+            maxFiles: this.#maxFiles,
+            maxCacheSize: this.#maxCacheSize,
+            chunkSize: CHUNK_SIZE,
+        };
+    }
+    /**
+     * Convert a bare filename, path, or URL to a UNIX-style path.
+     */
+    #getPath(nameOrURL) {
+        const url = typeof nameOrURL === 'string' ? new URL(nameOrURL, 'file://localhost/') : nameOrURL;
+        return url.pathname;
+    }
+}
+//# sourceMappingURL=CloudflareWorkerVFS.js.map