@livestore/sqlite-wasm 0.4.0-dev.0 → 0.4.0-dev.10

package/src/cf/test/sql/cloudflare-sql-vfs-core.test.ts

@@ -0,0 +1,433 @@
+/// <reference types="vitest/globals" />
+
+import type { CfTypes } from '@livestore/common-cf'
+import * as VFS from '@livestore/wa-sqlite/src/VFS.js'
+import { beforeEach, describe, expect, it } from 'vitest'
+import { CloudflareSqlVFS } from '../../mod.ts'
+
+describe('CloudflareSqlVFS - Core Functionality', () => {
+  let vfs: CloudflareSqlVFS
+  let mockSql: CfTypes.SqlStorage
+  let mockDatabase: Map<string, any[]>
+  let queryLog: string[]
+
+  beforeEach(async () => {
+    mockDatabase = new Map()
+    queryLog = []
+
+    // Mock SQL storage that mimics the Cloudflare DurableObject SQL API
+    mockSql = {
+      exec: <T extends Record<string, CfTypes.SqlStorageValue>>(
+        query: string,
+        ...bindings: any[]
+      ): CfTypes.SqlStorageCursor<T> => {
+        queryLog.push(`${query} [${bindings.join(', ')}]`)
+
+        // Simple SQL parser for testing - handles basic CREATE, INSERT, SELECT, UPDATE, DELETE
+        const normalizedQuery = query.trim().toUpperCase()
+
+        if (
+          normalizedQuery.includes('CREATE TABLE') ||
+          normalizedQuery.includes('CREATE INDEX') ||
+          normalizedQuery.includes('CREATE TRIGGER')
+        ) {
+          // Handle schema creation
+          return createMockCursor([] as any)
+        }
+
+        if (normalizedQuery.startsWith('INSERT OR REPLACE INTO VFS_BLOCKS')) {
+          const [filePath, blockId, blockData] = bindings
+          const key = `blocks:${filePath}`
+          if (!mockDatabase.has(key)) {
+            mockDatabase.set(key, [])
+          }
+          const blocks = mockDatabase.get(key)!
+          const existingIndex = blocks.findIndex((b: any) => b.block_id === blockId)
+          const blockEntry = { file_path: filePath, block_id: blockId, block_data: blockData }
+
+          if (existingIndex >= 0) {
+            blocks[existingIndex] = blockEntry
+          } else {
+            blocks.push(blockEntry)
+          }
+          return createMockCursor([] as any)
+        }
+
+        if (normalizedQuery.startsWith('INSERT INTO VFS_FILES')) {
+          const [filePath, fileSize, flags, createdAt, modifiedAt] = bindings
+          mockDatabase.set(`file:${filePath}`, {
+            file_path: filePath as string,
+            file_size: fileSize as number,
+            flags: flags as number,
+            created_at: createdAt as number,
+            modified_at: modifiedAt as number,
+          } as any)
+          return createMockCursor([] as any)
+        }
+
+        if (normalizedQuery.startsWith('SELECT') && normalizedQuery.includes('FROM VFS_FILES')) {
+          if (normalizedQuery.includes('WHERE FILE_PATH = ?')) {
+            const [filePath] = bindings
+            const fileData = mockDatabase.get(`file:${filePath}`)
+            return createMockCursor(fileData ? [fileData] : ([] as any))
+          }
+          return createMockCursor([] as any)
+        }
+
+        if (normalizedQuery.startsWith('SELECT') && normalizedQuery.includes('FROM VFS_BLOCKS')) {
+          if (normalizedQuery.includes('WHERE FILE_PATH = ?')) {
+            const filePath = bindings[0]
+            const blocks = mockDatabase.get(`blocks:${filePath}`) || []
+
+            if (normalizedQuery.includes('AND BLOCK_ID IN')) {
+              const requestedBlockIds = bindings.slice(1)
+              const matchingBlocks = blocks.filter((b: any) => requestedBlockIds.includes(b.block_id))
+              return createMockCursor(matchingBlocks as any)
+            }
+
+            return createMockCursor(blocks as any)
+          }
+          return createMockCursor([] as any)
+        }
+
+        if (normalizedQuery.startsWith('UPDATE VFS_FILES')) {
+          if (normalizedQuery.includes('SET FILE_SIZE = ?')) {
+            const [newSize, filePath] = bindings
+            const fileData = mockDatabase.get(`file:${filePath}`) as any
+            if (fileData) {
+              fileData.file_size = newSize as number
+              fileData.modified_at = Math.floor(Date.now() / 1000)
+            }
+          }
+          return createMockCursor([] as any)
+        }
+
+        if (normalizedQuery.startsWith('DELETE FROM VFS_BLOCKS')) {
+          const [filePath, minBlockId] = bindings
+          const blocks = mockDatabase.get(`blocks:${filePath}`)
+          if (blocks) {
+            const filteredBlocks = blocks.filter((b: any) => b.block_id < minBlockId)
+            mockDatabase.set(`blocks:${filePath}`, filteredBlocks)
+          }
+          return createMockCursor([] as any)
+        }
+
+        if (normalizedQuery.startsWith('DELETE FROM VFS_FILES')) {
+          const [filePath] = bindings
+          mockDatabase.delete(`file:${filePath}`)
+          mockDatabase.delete(`blocks:${filePath}`)
+          return createMockCursor([] as any)
+        }
+
+        // Default empty result for unhandled queries
+        console.warn('Unhandled query:', query, bindings)
+        return createMockCursor([] as any)
+      },
+
+      get databaseSize(): number {
+        return 1024 * 1024 // Mock 1MB database
+      },
+
+      Cursor: {} as any,
+      Statement: {} as any,
+    } as CfTypes.SqlStorage
+
+    function createMockCursor<T extends Record<string, CfTypes.SqlStorageValue>>(
+      data: T[],
+    ): CfTypes.SqlStorageCursor<T> {
+      let index = 0
+
+      return {
+        next: () => {
+          if (index < data.length) {
+            return { done: false, value: data[index++] }
+          }
+          return { done: true }
+        },
+        toArray: () => data,
+        one: () => {
+          if (data.length === 0) {
+            throw new Error('No results')
+          }
+          return data[0]
+        },
+        raw: function* () {
+          for (const item of data) {
+            yield Object.values(item) as CfTypes.SqlStorageValue[]
+          }
+        },
+        columnNames: Object.keys(data[0] || {}),
+        get rowsRead() {
+          return data.length
+        },
+        get rowsWritten() {
+          return 0
+        },
+        [Symbol.iterator]: function* () {
+          for (const item of data) {
+            yield item
+          }
+        },
+      } as CfTypes.SqlStorageCursor<T>
+    }
+
+    vfs = new CloudflareSqlVFS('test-sql-vfs', mockSql, {})
+    await vfs.isReady()
+  })
+
+  describe('Basic File Operations', () => {
+    it('should create and open files', async () => {
+      const path = '/test/basic.db'
+      const fileId = 1
+      const flags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      const pOutFlags = new DataView(new ArrayBuffer(4))
+
+      const result = vfs.jOpen(path, fileId, flags, pOutFlags)
+      expect(result).toBe(VFS.SQLITE_OK)
+      expect(pOutFlags.getUint32(0, true)).toBe(flags)
+
+      expect(vfs.jClose(fileId)).toBe(VFS.SQLITE_OK)
+
+      // Verify file was created in mock database
+      expect(mockDatabase.has(`file:${path}`)).toBe(true)
+    })
+
+    it('should handle file access checks', async () => {
+      const path = '/test/access.db'
+      const fileId = 1
+      const flags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      const pOutFlags = new DataView(new ArrayBuffer(4))
+
+      // File doesn't exist initially
+      const pResOut = new DataView(new ArrayBuffer(4))
+      expect(vfs.jAccess(path, VFS.SQLITE_ACCESS_EXISTS, pResOut)).toBe(VFS.SQLITE_OK)
+      expect(pResOut.getUint32(0, true)).toBe(0)
+
+      // Create file
+      vfs.jOpen(path, fileId, flags, pOutFlags)
+      vfs.jClose(fileId)
+
+      // File should exist now
+      expect(vfs.jAccess(path, VFS.SQLITE_ACCESS_EXISTS, pResOut)).toBe(VFS.SQLITE_OK)
+      expect(pResOut.getUint32(0, true)).toBe(1)
+    })
+
+    it('should handle basic read/write operations', async () => {
+      const path = '/test/readwrite.db'
+      const fileId = 1
+      const flags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      const pOutFlags = new DataView(new ArrayBuffer(4))
+
+      vfs.jOpen(path, fileId, flags, pOutFlags)
+
+      // Write data
+      const testData = new TextEncoder().encode('Hello, SQL VFS!')
+      expect(vfs.jWrite(fileId, testData, 0)).toBe(VFS.SQLITE_OK)
+
+      // Read data back
+      const readBuffer = new Uint8Array(testData.length)
+      expect(vfs.jRead(fileId, readBuffer, 0)).toBe(VFS.SQLITE_OK)
+      expect(readBuffer).toEqual(testData)
+
+      vfs.jClose(fileId)
+    })
+
+    it('should handle file size operations', async () => {
+      const path = '/test/size.db'
+      const fileId = 1
+      const flags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      const pOutFlags = new DataView(new ArrayBuffer(4))
+
+      vfs.jOpen(path, fileId, flags, pOutFlags)
+
+      // Initial size should be 0
+      const pSize64 = new DataView(new ArrayBuffer(8))
+      expect(vfs.jFileSize(fileId, pSize64)).toBe(VFS.SQLITE_OK)
+      expect(pSize64.getBigInt64(0, true)).toBe(0n)
+
+      // Write data and check size
+      const testData = new Uint8Array(1000)
+      testData.fill(0xaa)
+      vfs.jWrite(fileId, testData, 0)
+
+      expect(vfs.jFileSize(fileId, pSize64)).toBe(VFS.SQLITE_OK)
+      expect(pSize64.getBigInt64(0, true)).toBe(1000n)
+
+      vfs.jClose(fileId)
+    })
+
+    it('should handle file truncation', async () => {
+      const path = '/test/truncate.db'
+      const fileId = 1
+      const flags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      const pOutFlags = new DataView(new ArrayBuffer(4))
+
+      vfs.jOpen(path, fileId, flags, pOutFlags)
+
+      // Write data
+      const testData = new Uint8Array(2000)
+      testData.fill(0xbb)
+      vfs.jWrite(fileId, testData, 0)
+
+      // Truncate to smaller size
+      expect(vfs.jTruncate(fileId, 500)).toBe(VFS.SQLITE_OK)
+
+      // Verify size
+      const pSize64 = new DataView(new ArrayBuffer(8))
+      expect(vfs.jFileSize(fileId, pSize64)).toBe(VFS.SQLITE_OK)
+      expect(pSize64.getBigInt64(0, true)).toBe(500n)
+
+      vfs.jClose(fileId)
+    })
+
+    it('should handle sync operations', async () => {
+      const path = '/test/sync.db'
+      const fileId = 1
+      const flags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      const pOutFlags = new DataView(new ArrayBuffer(4))
+
+      vfs.jOpen(path, fileId, flags, pOutFlags)
+
+      const testData = new TextEncoder().encode('Sync test data')
+      vfs.jWrite(fileId, testData, 0)
+
+      // Test different sync modes - should all be no-ops for SQL VFS
+      expect(vfs.jSync(fileId, VFS.SQLITE_SYNC_NORMAL)).toBe(VFS.SQLITE_OK)
+      expect(vfs.jSync(fileId, VFS.SQLITE_SYNC_FULL)).toBe(VFS.SQLITE_OK)
+      expect(vfs.jSync(fileId, VFS.SQLITE_SYNC_DATAONLY)).toBe(VFS.SQLITE_OK)
+
+      vfs.jClose(fileId)
+    })
+
+    it('should handle file deletion', async () => {
+      const path = '/test/delete.db'
+      const fileId = 1
+      const flags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      const pOutFlags = new DataView(new ArrayBuffer(4))
+
+      // Create file
+      vfs.jOpen(path, fileId, flags, pOutFlags)
+      const testData = new TextEncoder().encode('Delete test')
+      vfs.jWrite(fileId, testData, 0)
+      vfs.jClose(fileId)
+
+      // Delete file
+      expect(vfs.jDelete(path, 0)).toBe(VFS.SQLITE_OK)
+
+      // Verify file is gone
+      expect(mockDatabase.has(`file:${path}`)).toBe(false)
+      expect(mockDatabase.has(`blocks:${path}`)).toBe(false)
+    })
+  })
+
+  describe('VFS Management', () => {
+    it('should provide correct VFS characteristics', () => {
+      expect(vfs.jSectorSize(1)).toBe(4096)
+      expect(vfs.jDeviceCharacteristics(1)).toBe(VFS.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN)
+    })
+
+    it('should handle multiple files', async () => {
+      const files = [
+        { path: '/test/file1.db', id: 1 },
+        { path: '/test/file2.db', id: 2 },
+        { path: '/test/file3.db', id: 3 },
+      ]
+
+      const flags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      const pOutFlags = new DataView(new ArrayBuffer(4))
+
+      // Open all files
+      for (const file of files) {
+        expect(vfs.jOpen(file.path, file.id, flags, pOutFlags)).toBe(VFS.SQLITE_OK)
+      }
+
+      // Write different data to each
+      for (let i = 0; i < files.length; i++) {
+        const data = new TextEncoder().encode(`File ${i + 1} data`)
+        expect(vfs.jWrite(files[i]?.id ?? 0, data, 0)).toBe(VFS.SQLITE_OK)
+      }
+
+      // Read back and verify
+      for (let i = 0; i < files.length; i++) {
+        const expected = new TextEncoder().encode(`File ${i + 1} data`)
+        const actual = new Uint8Array(expected.length)
+        expect(vfs.jRead(files[i]?.id ?? 0, actual, 0)).toBe(VFS.SQLITE_OK)
+        expect(actual).toEqual(expected)
+      }
+
+      // Close all files
+      for (const file of files) {
+        expect(vfs.jClose(file.id)).toBe(VFS.SQLITE_OK)
+      }
+    })
+
+    it('should provide VFS statistics', () => {
+      const stats = vfs.getStats()
+      expect(stats).toHaveProperty('activeFiles')
+      expect(stats).toHaveProperty('openFiles')
+      expect(stats).toHaveProperty('maxFiles')
+      expect(stats).toHaveProperty('blockSize')
+      expect(stats).toHaveProperty('totalStoredBytes')
+      expect(stats.blockSize).toBe(64 * 1024)
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should handle invalid file IDs', () => {
+      const invalidFileId = 999
+      const buffer = new Uint8Array(100)
+
+      expect(vfs.jRead(invalidFileId, buffer, 0)).toBe(VFS.SQLITE_IOERR)
+      expect(vfs.jWrite(invalidFileId, buffer, 0)).toBe(VFS.SQLITE_IOERR)
+      expect(vfs.jTruncate(invalidFileId, 50)).toBe(VFS.SQLITE_IOERR)
+      expect(vfs.jSync(invalidFileId, 0)).toBe(VFS.SQLITE_IOERR)
+      expect(vfs.jClose(invalidFileId)).toBe(VFS.SQLITE_OK)
+    })
+
+    it('should handle invalid paths', () => {
+      const invalidPath = ''
+      const fileId = 1
+      const flags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      const pOutFlags = new DataView(new ArrayBuffer(4))
+
+      expect(vfs.jOpen(invalidPath, fileId, flags, pOutFlags)).toBe(VFS.SQLITE_OK)
+    })
+
+    it('should handle file operations on closed files', () => {
+      const path = '/test/closed.db'
+      const fileId = 1
+      const flags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      const pOutFlags = new DataView(new ArrayBuffer(4))
+
+      // Open and close file
+      vfs.jOpen(path, fileId, flags, pOutFlags)
+      vfs.jClose(fileId)
+
+      // Try to operate on closed file
+      const buffer = new Uint8Array(10)
+      expect(vfs.jRead(fileId, buffer, 0)).toBe(VFS.SQLITE_IOERR)
+      expect(vfs.jWrite(fileId, buffer, 0)).toBe(VFS.SQLITE_IOERR)
+    })
+  })
+
+  describe('Constants and Compatibility', () => {
+    it('should define correct VFS constants', () => {
+      expect(VFS.SQLITE_OK).toBe(0)
+      expect(VFS.SQLITE_IOERR).toBe(10)
+      expect(VFS.SQLITE_CANTOPEN).toBe(14)
+      expect(VFS.SQLITE_READONLY).toBe(8)
+      expect(VFS.SQLITE_IOERR_SHORT_READ).toBe(522)
+      expect(VFS.SQLITE_IOERR_WRITE).toBe(778)
+      expect(VFS.SQLITE_IOERR_TRUNCATE).toBe(1546)
+    })
+
+    it('should handle VFS flags correctly', () => {
+      expect(VFS.SQLITE_OPEN_CREATE).toBeTruthy()
+      expect(VFS.SQLITE_OPEN_READWRITE).toBeTruthy()
+      expect(VFS.SQLITE_OPEN_READONLY).toBeTruthy()
+      expect(VFS.SQLITE_OPEN_MAIN_DB).toBeTruthy()
+      expect(VFS.SQLITE_OPEN_WAL).toBeTruthy()
+      expect(VFS.SQLITE_OPEN_MAIN_JOURNAL).toBeTruthy()
+    })
+  })
+})

package/src/load-wasm/mod.node.ts

@@ -1,6 +1,5 @@
-import * as WaSqlite from '@livestore/wa-sqlite'
-// @ts-expect-error TODO fix types in wa-sqlite
 import WaSqliteFactory from '@livestore/wa-sqlite/dist/wa-sqlite.node.mjs'
+import * as WaSqlite from '@livestore/wa-sqlite/src/sqlite-api.js'
 
 export const loadSqlite3Wasm = async () => {
   const module = await WaSqliteFactory()

package/src/load-wasm/mod.workerd.ts

@@ -0,0 +1,26 @@
+import * as WaSqlite from '@livestore/wa-sqlite'
+import WaSqliteFactory from '@livestore/wa-sqlite/dist/wa-sqlite.mjs'
+
+// @ts-expect-error TODO fix types in wa-sqlite
+import wasm from '@livestore/wa-sqlite/dist/wa-sqlite.wasm'
+
+export const loadSqlite3Wasm = async () => {
+  // It seems we need to pass in the wasm binary directly for workerd to work
+  const module = await WaSqliteFactory({
+    instantiateWasm: (info: any, receiveInstance: any) => {
+      try {
+        // Use the pre-compiled module directly
+        const instance = new WebAssembly.Instance(wasm, info)
+        receiveInstance(instance, wasm)
+        return instance.exports
+      } catch (error) {
+        console.error('Failed to instantiate WASM:', error)
+        throw error
+      }
+    },
+  })
+  const sqlite3 = WaSqlite.Factory(module)
+  // @ts-expect-error TODO fix types
+  sqlite3.module = module
+  return sqlite3
+}

package/src/make-sqlite-db.ts

@@ -7,6 +7,7 @@ import type {
 } from '@livestore/common'
 import { SqliteDbHelper, SqliteError } from '@livestore/common'
 import { EventSequenceNumber } from '@livestore/common/schema'
+import type { SQLiteAPI } from '@livestore/wa-sqlite'
 import * as SqliteConstants from '@livestore/wa-sqlite/src/sqlite-constants.js'
 import { makeInMemoryDb } from './in-memory-vfs.ts'
 
@@ -175,15 +176,48 @@ export const makeSqliteDb = <
       // if (readOnly === true) {
       //   sqlite3.deserialize(db, 'main', bytes, bytes.length, bytes.length, FREE_ON_CLOSE | RESIZEABLE)
       // } else {
+      const ensureSuccess = (rc: number, operation: string) => {
+        if (rc !== SqliteConstants.SQLITE_OK) {
+          throw new SqliteError({
+            code: rc,
+            cause: new Error(`${operation} failed with rc=${rc}`),
+            note: 'Snapshot import failed during SQLite copy',
+          })
+        }
+      }
+
       if (source instanceof Uint8Array) {
+        const WAL_FILE_FORMAT = 2
+        if (source.length >= 24 && (source[18] === WAL_FILE_FORMAT || source[19] === WAL_FILE_FORMAT)) {
+          throw new SqliteError({
+            code: SqliteConstants.SQLITE_CANTOPEN,
+            cause: new Error('WAL snapshots are not supported'),
+            note: 'Import expects rollback-journal snapshots (journal_mode=DELETE). Please convert snapshot before importing.',
+          })
+        }
+
         const tmpDb = makeInMemoryDb(sqlite3)
         // TODO find a way to do this more efficiently with sqlite to avoid either of the deserialize + backup call
         // Maybe this can be done via the VFS API
-        sqlite3.deserialize(tmpDb.dbPointer, 'main', source, source.length, source.length, FREE_ON_CLOSE | RESIZEABLE)
-        sqlite3.backup(dbPointer, 'main', tmpDb.dbPointer, 'main')
-        sqlite3.close(tmpDb.dbPointer)
+        const rcDeserialize = sqlite3.deserialize(
+          tmpDb.dbPointer,
+          'main',
+          source,
+          source.length,
+          source.length,
+          FREE_ON_CLOSE | RESIZEABLE,
+        )
+        ensureSuccess(rcDeserialize, 'sqlite3.deserialize')
+
+        try {
+          const rcBackup = sqlite3.backup(dbPointer, 'main', tmpDb.dbPointer, 'main')
+          ensureSuccess(rcBackup, 'sqlite3.backup')
+        } finally {
+          sqlite3.close(tmpDb.dbPointer)
+        }
       } else {
-        sqlite3.backup(dbPointer, 'main', source.metadata.dbPointer, 'main')
+        const rcBackup = sqlite3.backup(dbPointer, 'main', source.metadata.dbPointer, 'main')
+        ensureSuccess(rcBackup, 'sqlite3.backup')
       }
 
       metadata.configureDb(sqliteDb)

package/src/node/NodeFS.ts

@@ -19,12 +19,10 @@ export class NodeFS extends FacadeVFS {
   // biome-ignore lint/correctness/noUnusedPrivateClassMembers: for debugging
   private lastError: Error | null = null
   private readonly directory: string
-  private readonly onShutdown: () => void
-  constructor(name: string, sqlite3: WaSqlite.SQLiteAPI, directory: string, onShutdown: () => void) {
+  constructor(name: string, sqlite3: WaSqlite.SQLiteAPI, directory: string) {
     super(name, sqlite3)
 
     this.directory = directory
-    this.onShutdown = onShutdown
   }
 
   getFilename(fileId: number): string {
@@ -104,8 +102,6 @@ export class NodeFS extends FacadeVFS {
 
   jClose(fileId: number): number {
     try {
-      this.onShutdown()
-
       const file = this.mapIdToFile.get(fileId)
       if (!file) return VFS.SQLITE_OK
 
@@ -167,8 +163,6 @@ export class NodeFS extends FacadeVFS {
 
   jDelete(zName: string, _syncDir: number): number {
     try {
-      this.onShutdown()
-
       const pathname = path.resolve(this.directory, zName)
       fs.unlinkSync(pathname)
       return VFS.SQLITE_OK
@@ -191,8 +185,6 @@ export class NodeFS extends FacadeVFS {
   }
 
   deleteDb(fileName: string) {
-    this.onShutdown()
-
     fs.unlinkSync(path.join(this.directory, fileName))
   }
 }

package/src/node/mod.ts

@@ -96,8 +96,6 @@ export const sqliteDbFactory = ({
       }),
   )
 
-const nodeFsVfsMap = new Map<string, NodeFS>()
-
 const makeNodeFsDb = ({
   sqlite3,
   fileName,
@@ -113,14 +111,11 @@ const makeNodeFsDb = ({
     // NOTE to keep the filePath short, we use the directory name in the vfs name
     // If this is becoming a problem, we can use a hashed version of the directory name
     const vfsName = `node-fs-${directory}`
-    if (nodeFsVfsMap.has(vfsName) === false) {
+    if (sqlite3.vfs_registered.has(vfsName) === false) {
       // TODO refactor with Effect FileSystem instead of using `node:fs` directly inside of NodeFS
-      const nodeFsVfs = new NodeFS(vfsName, (sqlite3 as any).module, directory, () => {
-        nodeFsVfsMap.delete(vfsName)
-      })
+      const nodeFsVfs = new NodeFS(vfsName, (sqlite3 as any).module, directory)
       // @ts-expect-error TODO fix types
       sqlite3.vfs_register(nodeFsVfs, false)
-      nodeFsVfsMap.set(vfsName, nodeFsVfs)
     }
 
     yield* fs.makeDirectory(directory, { recursive: true })
@@ -133,7 +128,5 @@ const makeNodeFsDb = ({
     // NOTE SQLite will return a "disk I/O error" if the file path is too long.
     const dbPointer = sqlite3.open_v2Sync(fileName, undefined, vfsName)
 
-    const vfs = nodeFsVfsMap.get(vfsName)!
-
-    return { dbPointer, vfs }
+    return { dbPointer, vfs: {} as UNUSED<'only needed in web adapter currently and should longer-term be removed'> }
   }).pipe(UnexpectedError.mapToUnexpectedError)