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

package/src/browser/opfs/AccessHandlePoolVFS.ts

@@ -2,7 +2,7 @@
 /// <reference lib="webworker" />
 
 import { shouldNeverHappen } from '@livestore/utils'
-import { Effect, Runtime, Schedule, type Scope, Stream } from '@livestore/utils/effect'
+import { type Context, Effect, Schedule, type Scope, Stream } from '@livestore/utils/effect'
 import { Opfs, type WebError } from '@livestore/utils/effect/browser'
 import * as VFS from '@livestore/wa-sqlite/src/VFS.js'
 
@@ -67,8 +67,8 @@ export class AccessHandlePoolVFS extends FacadeVFS {
   #directoryPath
   #directoryHandle: FileSystemDirectoryHandle | undefined
 
-  // Runtime for executing Effect operations
-  readonly #runtime: Runtime.Runtime<Opfs.Opfs | Scope.Scope>
+  // Context for executing Effect operations.
+  readonly #services: Context.Context<Opfs.Opfs | Scope.Scope>
 
   // The OPFS files all have randomly-generated names that do not match
   // the SQLite files whose data they contain. This map links those names
@@ -84,8 +84,8 @@ export class AccessHandlePoolVFS extends FacadeVFS {
   #mapIdToFile = new Map<number, { path: string; flags: number; accessHandle: FileSystemSyncAccessHandle }>()
 
   static create = Effect.fn(function* (name: string, directoryPath: string, module: any) {
-    const runtime = yield* Effect.runtime<Opfs.Opfs | Scope.Scope>()
-    const vfs = new AccessHandlePoolVFS({ name, directoryPath, module, runtime })
+    const services = yield* Effect.context<Opfs.Opfs | Scope.Scope>()
+    const vfs = new AccessHandlePoolVFS({ name, directoryPath, module, services })
     yield* Effect.promise(() => vfs.isReady())
     return vfs
   })
@@ -94,16 +94,16 @@ export class AccessHandlePoolVFS extends FacadeVFS {
     name,
     directoryPath,
     module,
-    runtime,
+    services,
   }: {
     name: string
     directoryPath: string
     module: any
-    runtime: Runtime.Runtime<Opfs.Opfs | Scope.Scope>
+    services: Context.Context<Opfs.Opfs | Scope.Scope>
   }) {
     super(name, module)
     this.#directoryPath = directoryPath
-    this.#runtime = runtime
+    this.#services = services
   }
 
   /**
@@ -116,7 +116,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
    * string that is not meaningful to the application.
    */
   getOpfsFileName = Effect.fn((zName: string) =>
-    Effect.gen(this, function* () {
+    Effect.gen({ self: this }, function* () {
       const path = this.#getPath(zName)
       const accessHandle = this.#mapPathToAccessHandle.get(path)!
       return this.#mapAccessHandleToName.get(accessHandle)!
@@ -133,7 +133,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
    * the file cannot be modified by other threads.
    */
   readFilePayload = Effect.fn((zName: string) =>
-    Effect.gen(this, function* () {
+    Effect.gen({ self: this }, function* () {
       const path = this.#getPath(zName)
       const accessHandle = this.#mapPathToAccessHandle.get(path)
 
@@ -141,7 +141,8 @@ export class AccessHandlePoolVFS extends FacadeVFS {
         return shouldNeverHappen('Cannot read payload for untracked OPFS path')
       }
 
-      const fileSize = yield* Opfs.Opfs.syncGetSize(accessHandle)
+      const opfs = yield* Opfs.Opfs
+      const fileSize = yield* opfs.syncGetSize(accessHandle)
       if (fileSize <= HEADER_OFFSET_DATA) {
         return shouldNeverHappen(
           `OPFS file too small to contain header and payload: size ${fileSize} < HEADER_OFFSET_DATA ${HEADER_OFFSET_DATA}`,
@@ -150,7 +151,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
 
       const payloadSize = fileSize - HEADER_OFFSET_DATA
       const payload = new Uint8Array(payloadSize)
-      const bytesRead = yield* Opfs.Opfs.syncRead(accessHandle, payload, { at: HEADER_OFFSET_DATA })
+      const bytesRead = yield* opfs.syncRead(accessHandle, payload, { at: HEADER_OFFSET_DATA })
       if (bytesRead !== payloadSize) {
         return shouldNeverHappen(`Failed to read full payload from OPFS file: read ${bytesRead}/${payloadSize}`)
       }
@@ -160,17 +161,18 @@ export class AccessHandlePoolVFS extends FacadeVFS {
   )
 
   resetAccessHandle = Effect.fn((zName: string) =>
-    Effect.gen(this, function* () {
+    Effect.gen({ self: this }, function* () {
       const path = this.#getPath(zName)
       const accessHandle = this.#mapPathToAccessHandle.get(path)!
-      yield* Opfs.Opfs.syncTruncate(accessHandle, HEADER_OFFSET_DATA)
+      const opfs = yield* Opfs.Opfs
+      yield* opfs.syncTruncate(accessHandle, HEADER_OFFSET_DATA)
       // accessHandle.write(new Uint8Array(), { at: HEADER_OFFSET_DATA })
       // accessHandle.flush()
     }),
   )
 
   override jOpen(zName: string, fileId: number, flags: number, pOutFlags: DataView): number {
-    return Effect.gen(this, function* () {
+    return Effect.gen({ self: this }, function* () {
       // First try to open a path that already exists in the file system.
       const name = zName as unknown
       const path = typeof name === 'string' && name !== '' ? this.#getPath(name) : Math.random().toString(36)
@@ -184,10 +186,10 @@ export class AccessHandlePoolVFS extends FacadeVFS {
         } else {
           // Out of unassociated files. This can be fixed by calling
           // addCapacity() from the application.
-          return yield* Effect.dieMessage('cannot create file')
+          return yield* Effect.die(new Error('cannot create file'))
         }
       }
-      if (accessHandle == null) return yield* Effect.dieMessage('file not found')
+      if (accessHandle == null) return yield* Effect.die(new Error('file not found'))
 
       // Subsequent methods are only passed the fileId, so make sure we have
       // a way to get the file resources.
@@ -198,16 +200,17 @@ export class AccessHandlePoolVFS extends FacadeVFS {
       return VFS.SQLITE_OK
     }).pipe(
       Effect.tapCauseLogPretty,
-      Effect.catchAllCause(() => Effect.succeed(VFS.SQLITE_CANTOPEN)),
-      Runtime.runSync(this.#runtime),
+      Effect.catchCause(() => Effect.succeed(VFS.SQLITE_CANTOPEN)),
+      Effect.runSyncWith(this.#services),
     )
   }
 
   override jClose(fileId: number): number {
-    return Effect.gen(this, function* () {
+    return Effect.gen({ self: this }, function* () {
       const file = this.#mapIdToFile.get(fileId)
       if (file !== undefined) {
-        yield* Opfs.Opfs.syncFlush(file.accessHandle)
+        const opfs = yield* Opfs.Opfs
+        yield* opfs.syncFlush(file.accessHandle)
         this.#mapIdToFile.delete(fileId)
         if ((file.flags & VFS.SQLITE_OPEN_DELETEONCLOSE) !== 0) {
           yield* this.#deletePath(file.path)
@@ -216,15 +219,16 @@ export class AccessHandlePoolVFS extends FacadeVFS {
       return VFS.SQLITE_OK
     }).pipe(
       Effect.tapCauseLogPretty,
-      Effect.catchAllCause(() => Effect.succeed(VFS.SQLITE_IOERR_CLOSE)),
-      Runtime.runSync(this.#runtime),
+      Effect.catchCause(() => Effect.succeed(VFS.SQLITE_IOERR_CLOSE)),
+      Effect.runSyncWith(this.#services),
     )
   }
 
   override jRead(fileId: number, pData: Uint8Array<ArrayBuffer>, iOffset: number): number {
-    return Effect.gen(this, function* () {
+    return Effect.gen({ self: this }, function* () {
       const file = this.#mapIdToFile.get(fileId)!
-      const nBytes = yield* Opfs.Opfs.syncRead(file.accessHandle, pData.subarray(), {
+      const opfs = yield* Opfs.Opfs
+      const nBytes = yield* opfs.syncRead(file.accessHandle, pData.subarray(), {
         at: HEADER_OFFSET_DATA + iOffset,
       })
       if (nBytes < pData.byteLength) {
@@ -234,63 +238,67 @@ export class AccessHandlePoolVFS extends FacadeVFS {
       return VFS.SQLITE_OK
     }).pipe(
       Effect.tapCauseLogPretty,
-      Effect.catchAllCause(() => Effect.succeed(VFS.SQLITE_IOERR_READ)),
-      Runtime.runSync(this.#runtime),
+      Effect.catchCause(() => Effect.succeed(VFS.SQLITE_IOERR_READ)),
+      Effect.runSyncWith(this.#services),
     )
   }
 
   override jWrite(fileId: number, pData: Uint8Array<ArrayBuffer>, iOffset: number): number {
-    return Effect.gen(this, function* () {
+    return Effect.gen({ self: this }, function* () {
       const file = this.#mapIdToFile.get(fileId)!
-      const nBytes = yield* Opfs.Opfs.syncWrite(file.accessHandle, pData.subarray(), {
+      const opfs = yield* Opfs.Opfs
+      const nBytes = yield* opfs.syncWrite(file.accessHandle, pData.subarray(), {
         at: HEADER_OFFSET_DATA + iOffset,
       })
       if (nBytes !== pData.byteLength) {
-        return yield* Effect.dieMessage(`Wrote ${nBytes} bytes, expected ${pData.byteLength}`)
+        return yield* Effect.die(new Error(`Wrote ${nBytes} bytes, expected ${pData.byteLength}`))
       }
       return VFS.SQLITE_OK
     }).pipe(
       Effect.tapCauseLogPretty,
-      Effect.catchAllCause(() => Effect.succeed(VFS.SQLITE_IOERR_WRITE)),
-      Runtime.runSync(this.#runtime),
+      Effect.catchCause(() => Effect.succeed(VFS.SQLITE_IOERR_WRITE)),
+      Effect.runSyncWith(this.#services),
     )
   }
 
   override jTruncate(fileId: number, iSize: number): number {
-    return Effect.gen(this, function* () {
+    return Effect.gen({ self: this }, function* () {
       const file = this.#mapIdToFile.get(fileId)!
-      yield* Opfs.Opfs.syncTruncate(file.accessHandle, HEADER_OFFSET_DATA + iSize)
+      const opfs = yield* Opfs.Opfs
+      yield* opfs.syncTruncate(file.accessHandle, HEADER_OFFSET_DATA + iSize)
       return VFS.SQLITE_OK
     }).pipe(
       Effect.tapCauseLogPretty,
-      Effect.catchAllCause(() => Effect.succeed(VFS.SQLITE_IOERR_TRUNCATE)),
-      Runtime.runSync(this.#runtime),
+      Effect.catchCause(() => Effect.succeed(VFS.SQLITE_IOERR_TRUNCATE)),
+      Effect.runSyncWith(this.#services),
     )
   }
 
   override jSync(fileId: number, _flags: number): number {
-    return Effect.gen(this, function* () {
+    return Effect.gen({ self: this }, function* () {
       const file = this.#mapIdToFile.get(fileId)!
-      yield* Opfs.Opfs.syncFlush(file.accessHandle)
+      const opfs = yield* Opfs.Opfs
+      yield* opfs.syncFlush(file.accessHandle)
       return VFS.SQLITE_OK
     }).pipe(
       Effect.tapCauseLogPretty,
-      Effect.catchAllCause(() => Effect.succeed(VFS.SQLITE_IOERR_FSYNC)),
-      Runtime.runSync(this.#runtime),
+      Effect.catchCause(() => Effect.succeed(VFS.SQLITE_IOERR_FSYNC)),
+      Effect.runSyncWith(this.#services),
     )
   }
 
   override jFileSize(fileId: number, pSize64: DataView): number {
-    return Effect.gen(this, function* () {
+    return Effect.gen({ self: this }, function* () {
       const file = this.#mapIdToFile.get(fileId)!
-      const opfsFileSize = yield* Opfs.Opfs.syncGetSize(file.accessHandle)
+      const opfs = yield* Opfs.Opfs
+      const opfsFileSize = yield* opfs.syncGetSize(file.accessHandle)
       const size = opfsFileSize - HEADER_OFFSET_DATA
       pSize64.setBigInt64(0, BigInt(size), true)
       return VFS.SQLITE_OK
     }).pipe(
       Effect.tapCauseLogPretty,
-      Effect.catchAllCause(() => Effect.succeed(VFS.SQLITE_IOERR_FSTAT)),
-      Runtime.runSync(this.#runtime),
+      Effect.catchCause(() => Effect.succeed(VFS.SQLITE_IOERR_FSTAT)),
+      Effect.runSyncWith(this.#services),
     )
   }
 
@@ -303,35 +311,35 @@ export class AccessHandlePoolVFS extends FacadeVFS {
   }
 
   override jAccess(zName: string, _flags: number, pResOut: DataView): number {
-    return Effect.gen(this, function* () {
+    return Effect.gen({ self: this }, function* () {
       const path = this.#getPath(zName)
       pResOut.setInt32(0, this.#mapPathToAccessHandle.has(path) === true ? 1 : 0, true)
       return VFS.SQLITE_OK
     }).pipe(
       Effect.tapCauseLogPretty,
-      Effect.catchAllCause(() => Effect.succeed(VFS.SQLITE_IOERR_ACCESS)),
-      Runtime.runSync(this.#runtime),
+      Effect.catchCause(() => Effect.succeed(VFS.SQLITE_IOERR_ACCESS)),
+      Effect.runSyncWith(this.#services),
     )
   }
 
   override jDelete(zName: string, _syncDir: number): number {
-    return Effect.gen(this, function* () {
+    return Effect.gen({ self: this }, function* () {
       const path = this.#getPath(zName)
       yield* this.#deletePath(path)
       return VFS.SQLITE_OK
     }).pipe(
       Effect.tapCauseLogPretty,
-      Effect.catchAllCause(() => Effect.succeed(VFS.SQLITE_IOERR_DELETE)),
-      Runtime.runSync(this.#runtime),
+      Effect.catchCause(() => Effect.succeed(VFS.SQLITE_IOERR_DELETE)),
+      Effect.runSyncWith(this.#services),
     )
   }
 
   close() {
-    this.#releaseAccessHandles().pipe(Runtime.runPromise(this.#runtime))
+    this.#releaseAccessHandles().pipe(Effect.runPromiseWith(this.#services))
   }
 
   async isReady() {
-    return Effect.gen(this, function* () {
+    return Effect.gen({ self: this }, function* () {
       if (this.#directoryHandle == null) {
         // All files are stored in a single directory.
         this.#directoryHandle = yield* Opfs.getDirectoryHandleByPath(this.#directoryPath, { create: true })
@@ -342,7 +350,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
         }
       }
       return true
-    }).pipe(Runtime.runPromise(this.#runtime))
+    }).pipe(Effect.runPromiseWith(this.#services))
   }
 
   /**
@@ -373,11 +381,12 @@ export class AccessHandlePoolVFS extends FacadeVFS {
    * Increase the capacity of the file system by n.
    */
   addCapacity: (n: number) => Effect.Effect<void, WebError.WebError, Opfs.Opfs | Scope.Scope> = Effect.fn((n: number) =>
-    Effect.repeatN(
-      Effect.gen(this, function* () {
+    Effect.replicateEffect(
+      Effect.gen({ self: this }, function* () {
         const name = Math.random().toString(36).replace('0.', '')
-        const accessHandle = yield* Opfs.Opfs.getFileHandle(this.#directoryHandle!, name, { create: true }).pipe(
-          Effect.andThen((handle) => Opfs.Opfs.createSyncAccessHandle(handle)),
+        const opfs = yield* Opfs.Opfs
+        const accessHandle = yield* opfs.getFileHandle(this.#directoryHandle!, name, { create: true }).pipe(
+          Effect.andThen((handle) => opfs.createSyncAccessHandle(handle)),
           Effect.retry(Schedule.exponentialBackoff10Sec),
         )
         this.#mapAccessHandleToName.set(accessHandle, name)
@@ -385,6 +394,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
         yield* this.#setAssociatedPath(accessHandle, '', 0)
       }),
       n,
+      { discard: true },
     ),
   )
 
@@ -394,17 +404,18 @@ export class AccessHandlePoolVFS extends FacadeVFS {
    * file system.
    */
   removeCapacity = Effect.fn((n: number) =>
-    Effect.gen(this, function* () {
+    Effect.gen({ self: this }, function* () {
       let nRemoved = 0
       yield* Effect.forEach(
         this.#availableAccessHandles,
         (accessHandle) =>
-          Effect.gen(this, function* () {
+          Effect.gen({ self: this }, function* () {
             if (nRemoved === n || this.getSize() === this.getCapacity()) return nRemoved
 
             const name = this.#mapAccessHandleToName.get(accessHandle)!
             accessHandle.close()
-            yield* Opfs.Opfs.removeEntry(this.#directoryHandle!, name)
+            const opfs = yield* Opfs.Opfs
+            yield* opfs.removeEntry(this.#directoryHandle!, name)
             this.#mapAccessHandleToName.delete(accessHandle)
             this.#availableAccessHandles.delete(accessHandle)
             ++nRemoved
@@ -417,15 +428,16 @@ export class AccessHandlePoolVFS extends FacadeVFS {
   )
 
   #acquireAccessHandles = Effect.fn(() =>
-    Effect.gen(this, function* () {
-      const handlesStream = yield* Opfs.Opfs.values(this.#directoryHandle!)
+    Effect.gen({ self: this }, function* () {
+      const opfs = yield* Opfs.Opfs
+      const handlesStream = opfs.values(this.#directoryHandle!)
 
       yield* handlesStream.pipe(
         Stream.filter((handle): handle is FileSystemFileHandle => handle.kind === 'file'),
         Stream.mapEffect(
           (fileHandle) =>
-            Effect.gen(this, function* () {
-              const accessHandle = yield* Opfs.Opfs.createSyncAccessHandle(fileHandle)
+            Effect.gen({ self: this }, function* () {
+              const accessHandle = yield* opfs.createSyncAccessHandle(fileHandle)
               return {
                 accessHandle,
                 opfsFileName: fileHandle.name,
@@ -435,7 +447,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
           { concurrency: 'unbounded' },
         ),
         Stream.runForEach(({ opfsFileName, accessHandle, path }) =>
-          Effect.gen(this, function* () {
+          Effect.gen({ self: this }, function* () {
             this.#mapAccessHandleToName.set(accessHandle, opfsFileName)
             if (path !== '') {
               this.#mapPathToAccessHandle.set(path, accessHandle)
@@ -449,7 +461,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
   )
 
   #releaseAccessHandles = Effect.fn(() =>
-    Effect.gen(this, function* () {
+    Effect.gen({ self: this }, function* () {
       yield* Effect.forEach(
         this.#mapAccessHandleToName.keys(),
         (accessHandle) => Effect.sync(() => accessHandle.close()),
@@ -467,10 +479,11 @@ export class AccessHandlePoolVFS extends FacadeVFS {
    * @returns {string} path or empty string
    */
   #getAssociatedPath = Effect.fn((accessHandle: FileSystemSyncAccessHandle) =>
-    Effect.gen(this, function* () {
+    Effect.gen({ self: this }, function* () {
       // Read the path and digest of the path from the file.
       const corpus = new Uint8Array(HEADER_CORPUS_SIZE)
-      yield* Opfs.Opfs.syncRead(accessHandle, corpus, { at: 0 })
+      const opfs = yield* Opfs.Opfs
+      yield* opfs.syncRead(accessHandle, corpus, { at: 0 })
 
       // Delete files not expected to be present.
       const dataView = new DataView(corpus.buffer, corpus.byteOffset)
@@ -482,7 +495,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
       }
 
       const fileDigest = new Uint32Array(HEADER_DIGEST_SIZE / 4)
-      yield* Opfs.Opfs.syncRead(accessHandle, fileDigest, { at: HEADER_OFFSET_DIGEST })
+      yield* opfs.syncRead(accessHandle, fileDigest, { at: HEADER_OFFSET_DIGEST })
 
       // Verify the digest.
       const computedDigest = this.#computeDigest(corpus)
@@ -494,7 +507,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
           // truncated in #setAssociatedPath after the header is written. If
           // an interruption occurs right before the truncation then garbage
           // may remain in the file.
-          yield* Opfs.Opfs.syncTruncate(accessHandle, HEADER_OFFSET_DATA)
+          yield* opfs.syncTruncate(accessHandle, HEADER_OFFSET_DATA)
         }
         return new TextDecoder().decode(corpus.subarray(0, pathBytes))
       } else {
@@ -510,12 +523,12 @@ export class AccessHandlePoolVFS extends FacadeVFS {
    * Set the path on an OPFS file header.
    */
   #setAssociatedPath = Effect.fn((accessHandle: FileSystemSyncAccessHandle, path: string, flags: number) =>
-    Effect.gen(this, function* () {
+    Effect.gen({ self: this }, function* () {
       // Convert the path string to UTF-8.
       const corpus = new Uint8Array(HEADER_CORPUS_SIZE)
       const encodedResult = new TextEncoder().encodeInto(path, corpus)
       if (encodedResult.written >= HEADER_MAX_PATH_SIZE) {
-        return yield* Effect.dieMessage('path too long')
+        return yield* Effect.die(new Error('path too long'))
       }
 
       // Add the creation flags.
@@ -524,9 +537,10 @@ export class AccessHandlePoolVFS extends FacadeVFS {
 
       // Write the OPFS file header, including the digest.
       const digest = this.#computeDigest(corpus)
-      yield* Opfs.Opfs.syncWrite(accessHandle, corpus, { at: 0 })
-      yield* Opfs.Opfs.syncWrite(accessHandle, digest, { at: HEADER_OFFSET_DIGEST })
-      yield* Opfs.Opfs.syncFlush(accessHandle)
+      const opfs = yield* Opfs.Opfs
+      yield* opfs.syncWrite(accessHandle, corpus, { at: 0 })
+      yield* opfs.syncWrite(accessHandle, digest, { at: HEADER_OFFSET_DIGEST })
+      yield* opfs.syncFlush(accessHandle)
 
       if (path !== '') {
         this.#mapPathToAccessHandle.set(path, accessHandle)
@@ -534,7 +548,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
       } else {
         // This OPFS file doesn't represent any SQLite file so it doesn't
         // need to keep any data.
-        yield* Opfs.Opfs.syncTruncate(accessHandle, HEADER_OFFSET_DATA)
+        yield* opfs.syncTruncate(accessHandle, HEADER_OFFSET_DATA)
         this.#availableAccessHandles.add(accessHandle)
       }
     }),
@@ -578,7 +592,7 @@ export class AccessHandlePoolVFS extends FacadeVFS {
    * @param {string} path
    */
   #deletePath = Effect.fn((path: string) =>
-    Effect.gen(this, function* () {
+    Effect.gen({ self: this }, function* () {
       const accessHandle = this.#mapPathToAccessHandle.get(path)
       if (accessHandle !== undefined) {
         // Un-associate the SQLite path from the OPFS file.

package/src/browser/opfs/index.ts

@@ -1,10 +1,10 @@
-import { Effect, type Scope } from '@livestore/utils/effect'
+import { Effect, Semaphore, type Scope } from '@livestore/utils/effect'
 import type { Opfs } from '@livestore/utils/effect/browser'
 import type * as WaSqlite from '@livestore/wa-sqlite'
 
 import { AccessHandlePoolVFS } from './AccessHandlePoolVFS.ts'
 
-const semaphore = Effect.makeSemaphore(1).pipe(Effect.runSync)
+const semaphore = Semaphore.make(1).pipe(Effect.runSync)
 const opfsVfsMap = new Map<string, AccessHandlePoolVFS>()
 
 export const makeOpfsDb = ({

package/src/cf/CloudflareDurableObjectVFS.ts

@@ -223,10 +223,9 @@ export class CloudflareDurableObjectVFS extends FacadeVFS {
   override jFileSize(fileId: number, pSize64: DataView): number {
     try {
       const { path } = this.#getOpenFile(fileId)
-      const row = this.#sql.exec<{ max_page: number | null }>(
-        'SELECT MAX(page_no) AS max_page FROM vfs_pages WHERE file_path = ?',
-        path,
-      ).one()
+      const row = this.#sql
+        .exec<{ max_page: number | null }>('SELECT MAX(page_no) AS max_page FROM vfs_pages WHERE file_path = ?', path)
+        .one()
       const fileSize = row.max_page === null ? 0 : (row.max_page + 1) * PAGE_SIZE
       pSize64.setBigInt64(0, BigInt(fileSize), true)
       return VFS.SQLITE_OK

package/src/cf/test/README.md

@@ -23,9 +23,9 @@ Tests for the CloudflareWorkerVFS implementation, which uses DurableObjectStorag
 
 ### Testing Framework
 
-- **Vitest** with **@cloudflare/vitest-pool-workers** for Workers runtime testing
-- **Isolated Storage** - Each test gets fresh storage instances
-- **Real Runtime** - Tests run in the actual Cloudflare Workers runtime environment
+- **Vitest** in the Node test environment
+- **Mocked Cloudflare storage interfaces** - Tests provide in-memory `DurableObjectStorage` and SQL storage doubles
+- **Per-test setup** - Each test creates fresh mock storage and VFS instances
 
 ## VFS Implementation Comparison
 
@@ -69,11 +69,6 @@ Tests for the CloudflareWorkerVFS implementation, which uses DurableObjectStorag
    pnpm install
    ```
 
-2. Ensure Wrangler configuration is correct:
-   ```bash
-   # Check wrangler.toml exists and has correct Durable Object bindings
-   ```
-
 ### Test Commands
 
 ```bash
@@ -100,8 +95,9 @@ pnpm test --coverage
 
 ### Test Environment
 
-- **Runtime**: Cloudflare Workers (via workerd)
-- **Storage**: Isolated per-test storage instances
+- **Runtime**: Node via Vitest
+- **Storage**: Mocked Durable Object storage and SQL storage instances created per test
+- **Scope**: Unit/integration coverage for VFS behavior against Cloudflare-shaped interfaces, not workerd runtime coverage
 
 ## Test Structure
 
@@ -185,7 +181,7 @@ describe('Async Storage VFS Test Suite', () => {
 
 ### Automatic Cleanup
 
-- **Isolated Storage**: Each test gets fresh storage instances
+- **Fresh mock storage**: Each test creates new in-memory storage instances
 - **Temporary Files**: Cleaned up automatically
 - **Cache Management**: Memory caches cleared between tests
 
@@ -225,6 +221,7 @@ console.log('File metadata:', metadata)
 2. **Migration Tests**: Converting between storage backends
 3. **Stress Tests**: High-load scenarios for both implementations
 4. **Real SQLite Integration**: Tests with actual SQLite WASM
+5. **Workers Runtime Coverage**: Add dedicated workerd-based tests if runtime bindings or Wrangler configuration need validation
 
 ### Implementation Improvements
 

package/src/cf/test/async-storage/cloudflare-worker-vfs-advanced.test.ts

@@ -1,8 +1,9 @@
 /// <reference types="vitest/globals" />
 
+import { beforeEach, describe, expect, it } from 'vitest'
+
 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 { CloudflareWorkerVFS } from '../../mod.ts'
 

package/src/cf/test/async-storage/cloudflare-worker-vfs-core.test.ts

@@ -1,8 +1,9 @@
 /// <reference types="vitest/globals" />
 
+import { beforeEach, describe, expect, it } from 'vitest'
+
 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 { CloudflareWorkerVFS } from '../../mod.ts'
 

package/src/cf/test/async-storage/cloudflare-worker-vfs-integration.test.ts

@@ -1,8 +1,9 @@
 /// <reference types="vitest/globals" />
 
+import { beforeEach, describe, expect, it } from 'vitest'
+
 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 { CloudflareWorkerVFS } from '../../mod.ts'
 

package/src/cf/test/async-storage/cloudflare-worker-vfs-reliability.test.ts

@@ -1,8 +1,9 @@
 /// <reference types="vitest/globals" />
 
+import { beforeEach, describe, expect, it } from 'vitest'
+
 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 { CloudflareWorkerVFS } from '../../mod.ts'
 

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

@@ -1,8 +1,9 @@
 /// <reference types="vitest/globals" />
 
+import { beforeEach, describe, expect, it } from 'vitest'
+
 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 { CF_SQL_VFS_PAGE_SIZE, CloudflareDurableObjectVFS } from '../../mod.ts'
 
@@ -64,10 +65,12 @@ describe('CloudflareDurableObjectVFS - Core Functionality', () => {
         }
 
         // SELECT page_data FROM vfs_pages WHERE file_path = ? AND page_no = ?
-        if (normalizedQuery.startsWith('SELECT PAGE_DATA FROM VFS_PAGES WHERE FILE_PATH = ? AND PAGE_NO = ?') === true) {
+        if (
+          normalizedQuery.startsWith('SELECT PAGE_DATA FROM VFS_PAGES WHERE FILE_PATH = ? AND PAGE_NO = ?') === true
+        ) {
           const [filePath, pageNo] = bindings
           const data = mockPages.get(filePath as string)?.get(pageNo as number)
-          return createMockCursor(data !== undefined ? [{ page_data: data }] as any : [] as any)
+          return createMockCursor(data !== undefined ? ([{ page_data: data }] as any) : ([] as any))
         }
 
         // SELECT 1 AS x FROM vfs_pages LIMIT 1