Merge 'Add OPFS support to JavaScript bindings' from Nikita Sivukhin

This PR restructure JS packages and also adds support for OPFS for tursodatabase in browser. The new structure looks like this: 1. `@tursodatabase/database-common` - contains abstract JS code for bindings which depends only on `NativeDB` interface and not on the explicit native bindings 2. `@tursodatabase/database` - contains native bindings for the database and re-use `core` package 3. `@tursodatabase/database-browser` - contains bindings for browser (WASM + OPFS) As OPFS sync API (which is the most performant one in the web) works only in the web worker - this PR also make few operations async in order to run them as `napi-rs` AsyncTask. The following operations became async in `promise.ts` for node and browser: `pragma` / `exec` / `close`. Also, as few code pathes during initialization are non-async - they complicates integration of sync constructor in the browser with OPFS. So, right now - turso support only `connect` method for browser in non- memory mode. Closes #2927
2026-02-05 00:04:23 +01:00 · 2025-09-09 19:57:19 +03:00
parent cad8be1ed6 318124d864
commit 46c3bb21ad
47 changed files with 4286 additions and 5303 deletions
--- a/.github/workflows/napi.yml
+++ b/.github/workflows/napi.yml
@@ -19,6 +19,10 @@ defaults:
  run:
    working-directory: bindings/javascript

+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
  build:
    timeout-minutes: 20
@@ -27,20 +31,18 @@ jobs:
      matrix:
        settings:
          - host: windows-latest
-            build: |
-              yarn build --target x86_64-pc-windows-msvc
-              yarn test
            target: x86_64-pc-windows-msvc
+            build: yarn workspace @tursodatabase/database napi-build --target x86_64-pc-windows-msvc
          - host: ubuntu-latest
            target: x86_64-unknown-linux-gnu
            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian
-            build: yarn build --target x86_64-unknown-linux-gnu
+            build: yarn workspace @tursodatabase/database napi-build --target x86_64-unknown-linux-gnu
          - host: macos-latest
            target: aarch64-apple-darwin
-            build: yarn build --target aarch64-apple-darwin
+            build: yarn workspace @tursodatabase/database napi-build --target aarch64-apple-darwin
          - host: blacksmith-2vcpu-ubuntu-2404-arm
            target: aarch64-unknown-linux-gnu
-            build: yarn build --target aarch64-unknown-linux-gnu
+            build: yarn workspace @tursodatabase/database napi-build --target aarch64-unknown-linux-gnu
          - host: ubuntu-latest
            target: wasm32-wasip1-threads
            setup: |
@@ -52,7 +54,7 @@ jobs:
              export CMAKE_BUILD_PARALLEL_LEVEL=$(nproc)
              export TARGET_CXXFLAGS="--target=wasm32-wasi-threads --sysroot=$(pwd)/wasi-sdk-25.0-x86_64-linux/share/wasi-sysroot -pthread -mllvm -wasm-enable-sjlj -lsetjmp"
              export TARGET_CFLAGS="$TARGET_CXXFLAGS"
-              yarn build --target wasm32-wasip1-threads
+              yarn workspace @tursodatabase/database-browser build
    name: stable - ${{ matrix.settings.target }} - node@20
    runs-on: ${{ matrix.settings.host }}
    steps:
@@ -88,6 +90,8 @@ jobs:
        shell: bash
      - name: Install dependencies
        run: yarn install
+      - name: Build common
+        run: yarn workspace @tursodatabase/database-common build
      - name: Setup node x86
        uses: actions/setup-node@v4
        if: matrix.settings.target == 'x86_64-pc-windows-msvc'
@@ -110,8 +114,8 @@ jobs:
        with:
          name: bindings-${{ matrix.settings.target }}
          path: |
-            bindings/javascript/${{ env.APP_NAME }}.*.node
-            bindings/javascript/${{ env.APP_NAME }}.*.wasm
+            bindings/javascript/packages/native/${{ env.APP_NAME }}.*.node
+            bindings/javascript/packages/browser/${{ env.APP_NAME }}.*.wasm
          if-no-files-found: error
  test-linux-x64-gnu-binding:
    name: Test bindings on Linux-x64-gnu - node@${{ matrix.node }}
@@ -131,20 +135,21 @@ jobs:
          node-version: ${{ matrix.node }}
      - name: Install dependencies
        run: yarn install
-      - name: Download artifacts
+      - name: Build common
+        run: yarn workspace @tursodatabase/database-common build
+      - name: Download all artifacts
        uses: actions/download-artifact@v4
        with:
-          name: bindings-x86_64-unknown-linux-gnu
-          path: bindings/javascript
+          path: bindings/javascript/packages
+          merge-multiple: true
      - name: List packages
        run: ls -R .
        shell: bash
      - name: Test bindings
-        run: docker run --rm -v $(pwd):/build -w /build node:${{ matrix.node }}-slim yarn test
+        run: docker run --rm -v $(pwd):/build -w /build node:${{ matrix.node }}-slim yarn workspace @tursodatabase/database test
  publish:
    name: Publish
    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/v')
    permissions:
      contents: read
      id-token: write
@@ -156,35 +161,35 @@ jobs:
        uses: useblacksmith/setup-node@v5
        with:
          node-version: 20
-      - name: Install dependencies
-        run: yarn install
-      - name: create npm dirs
-        run: yarn napi create-npm-dirs
      - name: Download all artifacts
        uses: actions/download-artifact@v4
        with:
-          path: bindings/javascript/artifacts
-      - name: Move artifacts
-        run: yarn artifacts
-      - name: List packages
-        run: ls -R ./npm
-        shell: bash
+          path: bindings/javascript/packages
+          merge-multiple: true
+      - name: Install dependencies
+        run: yarn install
+      - name: Install dependencies
+        run: yarn tsc-build
      - name: Publish
+        if: "startsWith(github.ref, 'refs/tags/v')"
        run: |
          npm config set provenance true
          if git log -1 --pretty=%B | grep "^Turso [0-9]\+\.[0-9]\+\.[0-9]\+$";
          then
            echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
-            make publish-native
-            make publish-browser
+            npm publish --workspaces --access public
          elif git log -1 --pretty=%B | grep "^Turso [0-9]\+\.[0-9]\+\.[0-9]\+";
          then
            echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
-            make publish-native-next
-            make publish-browser-next
+            npm publish --workspaces --access public --tag next
          else
-            echo "Not a release, skipping publish"
+            echo "git log structure is unexpected, skip publishing"
+            npm publish --workspaces --dry-run
          fi
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Publish (dry-run)
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+        run: |
+          npm publish --workspaces --dry-run
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4331,6 +4331,7 @@ dependencies = [
 "napi",
 "napi-build",
 "napi-derive",
+ "tracing",
 "tracing-subscriber",
 "turso_core",
 ]
--- a/bindings/javascript/.gitignore
+++ b/bindings/javascript/.gitignore
@@ -197,4 +197,4 @@ Cargo.lock
 *.node
 *.wasm

-package.native.json
+npm
--- a/bindings/javascript/.npmignore
+++ b/bindings/javascript/.npmignore
@@ -11,3 +11,5 @@ yarn.lock
 .yarn
 __test__
 renovate.json
+examples
+perf
--- a/bindings/javascript/Cargo.toml
+++ b/bindings/javascript/Cargo.toml
@@ -15,9 +15,11 @@ turso_core = { workspace = true }
 napi = { version = "3.1.3", default-features = false, features = ["napi6"] }
 napi-derive = { version = "3.1.1", default-features = true }
 tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
+tracing.workspace = true

 [features]
 encryption = ["turso_core/encryption"]
+browser = []

 [build-dependencies]
 napi-build = "2.2.3"
--- a/bindings/javascript/browser.js
+++ b/bindings/javascript/browser.js
@@ -1 +0,0 @@
-export * from '@tursodatabase/database-wasm32-wasi'
--- a/bindings/javascript/index.js
+++ b/bindings/javascript/index.js
@@ -1,398 +0,0 @@
-// prettier-ignore
-/* eslint-disable */
-// @ts-nocheck
-/* auto-generated by NAPI-RS */
-
-import { createRequire } from 'node:module'
-const require = createRequire(import.meta.url)
-const __dirname = new URL('.', import.meta.url).pathname
-
-const { readFileSync } = require('node:fs')
-let nativeBinding = null
-const loadErrors = []
-
-const isMusl = () => {
-  let musl = false
-  if (process.platform === 'linux') {
-    musl = isMuslFromFilesystem()
-    if (musl === null) {
-      musl = isMuslFromReport()
-    }
-    if (musl === null) {
-      musl = isMuslFromChildProcess()
-    }
-  }
-  return musl
-}
-
-const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
-
-const isMuslFromFilesystem = () => {
-  try {
-    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
-  } catch {
-    return null
-  }
-}
-
-const isMuslFromReport = () => {
-  let report = null
-  if (typeof process.report?.getReport === 'function') {
-    process.report.excludeNetwork = true
-    report = process.report.getReport()
-  }
-  if (!report) {
-    return null
-  }
-  if (report.header && report.header.glibcVersionRuntime) {
-    return false
-  }
-  if (Array.isArray(report.sharedObjects)) {
-    if (report.sharedObjects.some(isFileMusl)) {
-      return true
-    }
-  }
-  return false
-}
-
-const isMuslFromChildProcess = () => {
-  try {
-    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
-  } catch (e) {
-    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
-    return false
-  }
-}
-
-function requireNative() {
-  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
-    try {
-      nativeBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
-    } catch (err) {
-      loadErrors.push(err)
-    }
-  } else if (process.platform === 'android') {
-    if (process.arch === 'arm64') {
-      try {
-        return require('./turso.android-arm64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-android-arm64')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'arm') {
-      try {
-        return require('./turso.android-arm-eabi.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-android-arm-eabi')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
-    }
-  } else if (process.platform === 'win32') {
-    if (process.arch === 'x64') {
-      try {
-        return require('./turso.win32-x64-msvc.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-win32-x64-msvc')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'ia32') {
-      try {
-        return require('./turso.win32-ia32-msvc.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-win32-ia32-msvc')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'arm64') {
-      try {
-        return require('./turso.win32-arm64-msvc.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-win32-arm64-msvc')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
-    }
-  } else if (process.platform === 'darwin') {
-    try {
-      return require('./turso.darwin-universal.node')
-    } catch (e) {
-      loadErrors.push(e)
-    }
-    try {
-      return require('@tursodatabase/database-darwin-universal')
-    } catch (e) {
-      loadErrors.push(e)
-    }
-    if (process.arch === 'x64') {
-      try {
-        return require('./turso.darwin-x64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-darwin-x64')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'arm64') {
-      try {
-        return require('./turso.darwin-arm64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-darwin-arm64')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
-    }
-  } else if (process.platform === 'freebsd') {
-    if (process.arch === 'x64') {
-      try {
-        return require('./turso.freebsd-x64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-freebsd-x64')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'arm64') {
-      try {
-        return require('./turso.freebsd-arm64.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-freebsd-arm64')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
-    }
-  } else if (process.platform === 'linux') {
-    if (process.arch === 'x64') {
-      if (isMusl()) {
-        try {
-          return require('./turso.linux-x64-musl.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          return require('@tursodatabase/database-linux-x64-musl')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      } else {
-        try {
-          return require('./turso.linux-x64-gnu.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          return require('@tursodatabase/database-linux-x64-gnu')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      }
-    } else if (process.arch === 'arm64') {
-      if (isMusl()) {
-        try {
-          return require('./turso.linux-arm64-musl.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          return require('@tursodatabase/database-linux-arm64-musl')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      } else {
-        try {
-          return require('./turso.linux-arm64-gnu.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          return require('@tursodatabase/database-linux-arm64-gnu')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      }
-    } else if (process.arch === 'arm') {
-      if (isMusl()) {
-        try {
-          return require('./turso.linux-arm-musleabihf.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          return require('@tursodatabase/database-linux-arm-musleabihf')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      } else {
-        try {
-          return require('./turso.linux-arm-gnueabihf.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          return require('@tursodatabase/database-linux-arm-gnueabihf')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      }
-    } else if (process.arch === 'riscv64') {
-      if (isMusl()) {
-        try {
-          return require('./turso.linux-riscv64-musl.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          return require('@tursodatabase/database-linux-riscv64-musl')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      } else {
-        try {
-          return require('./turso.linux-riscv64-gnu.node')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-        try {
-          return require('@tursodatabase/database-linux-riscv64-gnu')
-        } catch (e) {
-          loadErrors.push(e)
-        }
-      }
-    } else if (process.arch === 'ppc64') {
-      try {
-        return require('./turso.linux-ppc64-gnu.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-linux-ppc64-gnu')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 's390x') {
-      try {
-        return require('./turso.linux-s390x-gnu.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-linux-s390x-gnu')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
-    }
-  } else if (process.platform === 'openharmony') {
-    if (process.arch === 'arm64') {
-      try {
-        return require('./turso.linux-arm64-ohos.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-linux-arm64-ohos')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'x64') {
-      try {
-        return require('./turso.linux-x64-ohos.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-linux-x64-ohos')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else if (process.arch === 'arm') {
-      try {
-        return require('./turso.linux-arm-ohos.node')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-      try {
-        return require('@tursodatabase/database-linux-arm-ohos')
-      } catch (e) {
-        loadErrors.push(e)
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
-    }
-  } else {
-    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
-  }
-}
-
-nativeBinding = requireNative()
-
-if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
-  try {
-    nativeBinding = require('./turso.wasi.cjs')
-  } catch (err) {
-    if (process.env.NAPI_RS_FORCE_WASI) {
-      loadErrors.push(err)
-    }
-  }
-  if (!nativeBinding) {
-    try {
-      nativeBinding = require('@tursodatabase/database-wasm32-wasi')
-    } catch (err) {
-      if (process.env.NAPI_RS_FORCE_WASI) {
-        loadErrors.push(err)
-      }
-    }
-  }
-}
-
-if (!nativeBinding) {
-  if (loadErrors.length > 0) {
-    throw new Error(
-      `Cannot find native binding. ` +
-        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
-        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
-      { cause: loadErrors }
-    )
-  }
-  throw new Error(`Failed to load native binding`)
-}
-
-const { Database, Statement } = nativeBinding
-export { Database }
-export { Statement }
--- a/bindings/javascript/package-lock.json
+++ b/bindings/javascript/package-lock.json
--- a/bindings/javascript/package.browser.json
+++ b/bindings/javascript/package.browser.json
@@ -1,59 +0,0 @@
-{
-  "name": "@tursodatabase/database-browser",
-  "version": "0.1.5-pre.2",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/tursodatabase/turso"
-  },
-  "description": "The Turso database library specifically for browser/web environment",
-  "module": "./dist/promise.js",
-  "main": "./dist/promise.js",
-  "type": "module",
-  "exports": {
-    ".": "./dist/promise.js",
-    "./compat": "./dist/compat.js"
-  },
-  "files": [
-    "browser.js",
-    "index.js",
-    "index.d.ts",
-    "dist/**"
-  ],
-  "types": "index.d.ts",
-  "napi": {
-    "binaryName": "turso",
-    "targets": [
-      "wasm32-wasip1-threads"
-    ]
-  },
-  "license": "MIT",
-  "devDependencies": {
-    "@napi-rs/cli": "^3.0.4",
-    "@napi-rs/wasm-runtime": "^1.0.1",
-    "ava": "^6.0.1",
-    "better-sqlite3": "^11.9.1",
-    "typescript": "^5.9.2"
-  },
-  "ava": {
-    "timeout": "3m"
-  },
-  "engines": {
-    "node": ">= 10"
-  },
-  "scripts": {
-    "artifacts": "napi artifacts",
-    "build": "npm exec tsc && napi build --platform --release --esm",
-    "build:debug": "npm exec tsc && napi build --platform",
-    "prepublishOnly": "npm exec tsc && napi prepublish -t npm --skip-optional-publish",
-    "test": "true",
-    "universal": "napi universalize",
-    "version": "napi version"
-  },
-  "packageManager": "yarn@4.9.2",
-  "imports": {
-    "#entry-point": {
-      "types": "./index.d.ts",
-      "browser": "./browser.js"
-    }
-  }
-}
--- a/bindings/javascript/package.json
+++ b/bindings/javascript/package.json
@@ -1,64 +1,12 @@
 {
-  "name": "@tursodatabase/database",
-  "version": "0.1.5-pre.3",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/tursodatabase/turso"
-  },
-  "description": "The Turso database library",
-  "module": "./dist/promise.js",
-  "main": "./dist/promise.js",
-  "type": "module",
-  "exports": {
-    ".": "./dist/promise.js",
-    "./compat": "./dist/compat.js"
-  },
-  "files": [
-    "browser.js",
-    "index.js",
-    "index.d.ts",
-    "dist/**"
-  ],
-  "types": "index.d.ts",
-  "napi": {
-    "binaryName": "turso",
-    "targets": [
-      "x86_64-unknown-linux-gnu",
-      "x86_64-pc-windows-msvc",
-      "universal-apple-darwin",
-      "aarch64-unknown-linux-gnu",
-      "wasm32-wasip1-threads"
-    ]
-  },
-  "license": "MIT",
-  "devDependencies": {
-    "@napi-rs/cli": "^3.0.4",
-    "@napi-rs/wasm-runtime": "^1.0.1",
-    "ava": "^6.0.1",
-    "better-sqlite3": "^11.9.1",
-    "typescript": "^5.9.2"
-  },
-  "ava": {
-    "timeout": "3m"
-  },
-  "engines": {
-    "node": ">= 10"
-  },
  "scripts": {
-    "artifacts": "napi artifacts",
-    "build": "npm exec tsc && napi build --platform --release --esm",
-    "build:debug": "npm exec tsc && napi build --platform",
-    "prepublishOnly": "npm exec tsc && napi prepublish -t npm",
-    "test": "true",
-    "universal": "napi universalize",
-    "version": "napi version"
+    "build": "npm run build --workspaces",
+    "tsc-build": "npm run tsc-build --workspaces",
+    "test": "npm run test --workspaces"
  },
-  "packageManager": "yarn@4.9.2",
-  "imports": {
-    "#entry-point": {
-      "types": "./index.d.ts",
-      "browser": "./browser.js",
-      "node": "./index.js"
-    }
-  }
-}
+  "workspaces": [
+    "packages/common",
+    "packages/native",
+    "packages/browser"
+  ]
+}
--- a/bindings/javascript/packages/browser/README.md
+++ b/bindings/javascript/packages/browser/README.md
@@ -0,0 +1,124 @@
+<p align="center">
+  <h1 align="center">Turso Database for JavaScript in Browser</h1>
+</p>
+
+<p align="center">
+  <a title="JavaScript" target="_blank" href="https://www.npmjs.com/package/@tursodatabase/database"><img alt="npm" src="https://img.shields.io/npm/v/@tursodatabase/database"></a>
+  <a title="MIT" target="_blank" href="https://github.com/tursodatabase/turso/blob/main/LICENSE.md"><img src="http://img.shields.io/badge/license-MIT-orange.svg?style=flat-square"></a>
+</p>
+<p align="center">
+  <a title="Users Discord" target="_blank" href="https://tur.so/discord"><img alt="Chat with other users of Turso on Discord" src="https://img.shields.io/discord/933071162680958986?label=Discord&logo=Discord&style=social"></a>
+</p>
+
+---
+
+## About
+
+This package is the Turso embedded database library for JavaScript in Browser.
+
+> **⚠️ Warning:** This software is ALPHA, only use for development, testing, and experimentation. We are working to make it production ready, but do not use it for critical data right now.
+
+## Features
+
+- **SQLite compatible:** SQLite query language and file format support ([status](https://github.com/tursodatabase/turso/blob/main/COMPAT.md)).
+- **In-process**: No network overhead, runs directly in your Node.js process
+- **TypeScript support**: Full TypeScript definitions included
+
+## Installation
+
+```bash
+npm install @tursodatabase/database-browser
+```
+
+## Getting Started
+
+### In-Memory Database
+
+```javascript
+import { connect } from '@tursodatabase/database-browser';
+
+// Create an in-memory database
+const db = await connect(':memory:');
+
+// Create a table
+await db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)');
+
+// Insert data
+const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+await insert.run('Alice', 'alice@example.com');
+await insert.run('Bob', 'bob@example.com');
+
+// Query data
+const users = await db.prepare('SELECT * FROM users').all();
+console.log(users);
+// Output: [
+//   { id: 1, name: 'Alice', email: 'alice@example.com' },
+//   { id: 2, name: 'Bob', email: 'bob@example.com' }
+// ]
+```
+
+### File-Based Database
+
+```javascript
+import { connect } from '@tursodatabase/database-browser';
+
+// Create or open a database file
+const db = await connect('my-database.db');
+
+// Create a table
+await db.exec(`
+  CREATE TABLE IF NOT EXISTS posts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    content TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  )
+`);
+
+// Insert a post
+const insertPost = db.prepare('INSERT INTO posts (title, content) VALUES (?, ?)');
+const result = await insertPost.run('Hello World', 'This is my first blog post!');
+
+console.log(`Inserted post with ID: ${result.lastInsertRowid}`);
+```
+
+### Transactions
+
+```javascript
+import { connect } from '@tursodatabase/database-browser';
+
+const db = await connect('transactions.db');
+
+// Using transactions for atomic operations
+const transaction = db.transaction(async (users) => {
+  const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+  for (const user of users) {
+    await insert.run(user.name, user.email);
+  }
+});
+
+// Execute transaction
+await transaction([
+  { name: 'Alice', email: 'alice@example.com' },
+  { name: 'Bob', email: 'bob@example.com' }
+]);
+```
+
+## API Reference
+
+For complete API documentation, see [JavaScript API Reference](../../../../docs/javascript-api-reference.md).
+
+## Related Packages
+
+* The [@tursodatabase/serverless](https://www.npmjs.com/package/@tursodatabase/serverless) package provides a serverless driver with the same API.
+* The [@tursodatabase/sync](https://www.npmjs.com/package/@tursodatabase/sync) package provides bidirectional sync between a local Turso database and Turso Cloud. 
+
+## License
+
+This project is licensed under the [MIT license](../../LICENSE.md).
+
+## Support
+
+- [GitHub Issues](https://github.com/tursodatabase/turso/issues)
+- [Documentation](https://docs.turso.tech)
+- [Discord Community](https://tur.so/discord)
--- a/bindings/javascript/packages/browser/index.js
+++ b/bindings/javascript/packages/browser/index.js
@@ -1,7 +1,7 @@
 import {
  createOnMessage as __wasmCreateOnMessageForFsProxy,
  getDefaultContext as __emnapiGetDefaultContext,
-  instantiateNapiModuleSync as __emnapiInstantiateNapiModuleSync,
+  instantiateNapiModule as __emnapiInstantiateNapiModule,
  WASI as __WASI,
 } from '@napi-rs/wasm-runtime'

@@ -23,19 +23,25 @@ const __sharedMemory = new WebAssembly.Memory({

 const __wasmFile = await fetch(__wasmUrl).then((res) => res.arrayBuffer())

+export let MainWorker = null;
+
+function panic(name) {
+  throw new Error(`method ${name} must be invoked only from the main thread`);
+}
+
 const {
  instance: __napiInstance,
  module: __wasiModule,
  napiModule: __napiModule,
-} = __emnapiInstantiateNapiModuleSync(__wasmFile, {
+} = await __emnapiInstantiateNapiModule(__wasmFile, {
  context: __emnapiContext,
-  asyncWorkPoolSize: 4,
+  asyncWorkPoolSize: 1,
  wasi: __wasi,
  onCreateWorker() {
-    const worker = new Worker(new URL('./wasi-worker-browser.mjs', import.meta.url), {
+    const worker = new Worker(new URL('./worker.mjs', import.meta.url), {
      type: 'module',
    })
-
+    MainWorker = worker;
    return worker
  },
  overwriteImports(importObject) {
@@ -44,6 +50,13 @@ const {
      ...importObject.napi,
      ...importObject.emnapi,
      memory: __sharedMemory,
+      is_web_worker: () => false,
+      lookup_file: () => panic("lookup_file"),
+      read: () => panic("read"),
+      write: () => panic("write"),
+      sync: () => panic("sync"),
+      truncate: () => panic("truncate"),
+      size: () => panic("size"),
    }
    return importObject
  },
@@ -57,4 +70,8 @@ const {
 })
 export default __napiModule.exports
 export const Database = __napiModule.exports.Database
+export const Opfs = __napiModule.exports.Opfs
+export const OpfsFile = __napiModule.exports.OpfsFile
 export const Statement = __napiModule.exports.Statement
+export const connect = __napiModule.exports.connect
+export const initThreadPool = __napiModule.exports.initThreadPool
--- a/bindings/javascript/packages/browser/package.json
+++ b/bindings/javascript/packages/browser/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@tursodatabase/database-browser",
+  "version": "0.1.5-pre.3",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tursodatabase/turso"
+  },
+  "license": "MIT",
+  "main": "dist/promise.js",
+  "packageManager": "yarn@4.9.2",
+  "files": [
+    "index.js",
+    "worker.mjs",
+    "turso.wasm32-wasi.wasm",
+    "dist/**",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@napi-rs/cli": "^3.1.5",
+    "@vitest/browser": "^3.2.4",
+    "playwright": "^1.55.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "napi-build": "napi build --features browser --release --platform --target wasm32-wasip1-threads --no-js --manifest-path ../../Cargo.toml --output-dir . && rm index.d.ts turso.wasi* wasi* browser.js",
+    "tsc-build": "npm exec tsc",
+    "build": "npm run napi-build && npm run tsc-build",
+    "test": "CI=1 vitest --browser=chromium --run && CI=1 vitest --browser=firefox --run"
+  },
+  "napi": {
+    "binaryName": "turso",
+    "targets": [
+      "wasm32-wasip1-threads"
+    ]
+  },
+  "imports": {
+    "#index": "./index.js"
+  },
+  "dependencies": {
+    "@napi-rs/wasm-runtime": "^1.0.3",
+    "@tursodatabase/database-common": "^0.1.5-pre.3"
+  }
+}
--- a/bindings/javascript/packages/browser/promise.test.ts
+++ b/bindings/javascript/packages/browser/promise.test.ts
@@ -0,0 +1,95 @@
+import { expect, test, afterEach } from 'vitest'
+import { connect } from './promise.js'
+
+test('in-memory db', async () => {
+    const db = await connect(":memory:");
+    await db.exec("CREATE TABLE t(x)");
+    await db.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const stmt = db.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    const rows = await stmt.all([1]);
+    expect(rows).toEqual([{ x: 1 }, { x: 3 }]);
+})
+
+test('on-disk db', async () => {
+    const path = `test-${(Math.random() * 10000) | 0}.db`;
+    const db1 = await connect(path);
+    await db1.exec("CREATE TABLE t(x)");
+    await db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const stmt1 = db1.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    expect(stmt1.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+    const rows1 = await stmt1.all([1]);
+    expect(rows1).toEqual([{ x: 1 }, { x: 3 }]);
+    await db1.close();
+    stmt1.close();
+
+    const db2 = await connect(path);
+    const stmt2 = db2.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    expect(stmt2.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+    const rows2 = await stmt2.all([1]);
+    expect(rows2).toEqual([{ x: 1 }, { x: 3 }]);
+    db2.close();
+})
+
+test('attach', async () => {
+    const path1 = `test-${(Math.random() * 10000) | 0}.db`;
+    const path2 = `test-${(Math.random() * 10000) | 0}.db`;
+    const db1 = await connect(path1);
+    await db1.exec("CREATE TABLE t(x)");
+    await db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const db2 = await connect(path2);
+    await db2.exec("CREATE TABLE q(x)");
+    await db2.exec("INSERT INTO q VALUES (4), (5), (6)");
+
+    await db1.exec(`ATTACH '${path2}' as secondary`);
+
+    const stmt = db1.prepare("SELECT * FROM t UNION ALL SELECT * FROM secondary.q");
+    expect(stmt.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+    const rows = await stmt.all([1]);
+    expect(rows).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 4 }, { x: 5 }, { x: 6 }]);
+})
+
+test('blobs', async () => {
+    const db = await connect(":memory:");
+    const rows = await db.prepare("SELECT x'1020' as x").all();
+    expect(rows).toEqual([{ x: new Uint8Array([16, 32]) }])
+})
+
+
+test('example-1', async () => {
+    const db = await connect(':memory:');
+    await db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)');
+
+    const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+    await insert.run('Alice', 'alice@example.com');
+    await insert.run('Bob', 'bob@example.com');
+
+    const users = await db.prepare('SELECT * FROM users').all();
+    expect(users).toEqual([
+        { id: 1, name: 'Alice', email: 'alice@example.com' },
+        { id: 2, name: 'Bob', email: 'bob@example.com' }
+    ]);
+})
+
+test('example-2', async () => {
+    const db = await connect(':memory:');
+    await db.exec('CREATE TABLE users (name, email)');
+    // Using transactions for atomic operations
+    const transaction = db.transaction(async (users) => {
+        const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+        for (const user of users) {
+            await insert.run(user.name, user.email);
+        }
+    });
+
+    // Execute transaction
+    await transaction([
+        { name: 'Alice', email: 'alice@example.com' },
+        { name: 'Bob', email: 'bob@example.com' }
+    ]);
+
+    const rows = await db.prepare('SELECT * FROM users').all();
+    expect(rows).toEqual([
+        { name: 'Alice', email: 'alice@example.com' },
+        { name: 'Bob', email: 'bob@example.com' }
+    ]);
+})
--- a/bindings/javascript/packages/browser/promise.ts
+++ b/bindings/javascript/packages/browser/promise.ts
@@ -0,0 +1,78 @@
+import { DatabasePromise, NativeDatabase, DatabaseOpts, SqliteError } from "@tursodatabase/database-common"
+import { connect as nativeConnect, initThreadPool, MainWorker } from "#index";
+
+let workerRequestId = 0;
+class Database extends DatabasePromise {
+    files: string[];
+    constructor(db: NativeDatabase, files: string[], opts: DatabaseOpts = {}) {
+        super(db, opts)
+        this.files = files;
+    }
+    async close() {
+        let currentId = workerRequestId;
+        workerRequestId += this.files.length;
+
+        let tasks = [];
+        for (const file of this.files) {
+            (MainWorker as any).postMessage({ __turso__: "unregister", path: file, id: currentId });
+            tasks.push(waitFor(currentId));
+            currentId += 1;
+        }
+        await Promise.all(tasks);
+        this.db.close();
+    }
+}
+
+function waitFor(id: number): Promise<any> {
+    let waitResolve, waitReject;
+    const callback = msg => {
+        if (msg.data.id == id) {
+            if (msg.data.error != null) {
+                waitReject(msg.data.error)
+            } else {
+                waitResolve()
+            }
+            cleanup();
+        }
+    };
+    const cleanup = () => (MainWorker as any).removeEventListener("message", callback);
+
+    (MainWorker as any).addEventListener("message", callback);
+    const result = new Promise((resolve, reject) => {
+        waitResolve = resolve;
+        waitReject = reject;
+    });
+    return result;
+}
+
+/**
+ * Creates a new database connection asynchronously.
+ * 
+ * @param {string} path - Path to the database file.
+ * @param {Object} opts - Options for database behavior.
+ * @returns {Promise<Database>} - A promise that resolves to a Database instance.
+ */
+async function connect(path: string, opts: DatabaseOpts = {}): Promise<Database> {
+    if (path == ":memory:") {
+        const db = await nativeConnect(path, { tracing: opts.tracing });
+        return new Database(db, [], opts);
+    }
+    await initThreadPool();
+    if (MainWorker == null) {
+        throw new Error("panic: MainWorker is not set");
+    }
+
+    let currentId = workerRequestId;
+    workerRequestId += 2;
+
+    let dbHandlePromise = waitFor(currentId);
+    let walHandlePromise = waitFor(currentId + 1);
+    (MainWorker as any).postMessage({ __turso__: "register", path: `${path}`, id: currentId });
+    (MainWorker as any).postMessage({ __turso__: "register", path: `${path}-wal`, id: currentId + 1 });
+    await Promise.all([dbHandlePromise, walHandlePromise]);
+    const db = await nativeConnect(path, { tracing: opts.tracing });
+    const files = [path, `${path}-wal`];
+    return new Database(db, files, opts);
+}
+
+export { connect, Database, SqliteError }
--- a/bindings/javascript/packages/browser/tsconfig.json
+++ b/bindings/javascript/packages/browser/tsconfig.json
@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "module": "nodenext",
+    "target": "esnext",
+    "outDir": "dist/",
+    "lib": [
+      "es2020"
+    ],
+    "paths": {
+      "#index": [
+        "./index.js"
+      ]
+    }
+  },
+  "include": [
+    "*"
+  ]
+}
--- a/bindings/javascript/packages/browser/vitest.config.ts
+++ b/bindings/javascript/packages/browser/vitest.config.ts
@@ -0,0 +1,23 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  define: {
+    'process.env.NODE_DEBUG_NATIVE': 'false',
+  },
+  server: {
+    headers: {
+      "Cross-Origin-Embedder-Policy": "require-corp",
+      "Cross-Origin-Opener-Policy": "same-origin"
+    },
+  },
+  test: {
+    browser: {
+      enabled: true,
+      provider: 'playwright',
+      instances: [
+        { browser: 'chromium' },
+        { browser: 'firefox' }
+      ],
+    },
+  },
+})
--- a/bindings/javascript/packages/browser/worker.mjs
+++ b/bindings/javascript/packages/browser/worker.mjs
@@ -0,0 +1,160 @@
+import { instantiateNapiModuleSync, MessageHandler, WASI } from '@napi-rs/wasm-runtime'
+
+var fileByPath = new Map();
+var fileByHandle = new Map();
+let fileHandles = 0;
+var memory = null;
+
+function getUint8ArrayFromWasm(ptr, len) {
+  ptr = ptr >>> 0;
+  return new Uint8Array(memory.buffer).subarray(ptr, ptr + len);
+}
+
+
+async function registerFile(path) {
+  if (fileByPath.has(path)) {
+    return;
+  }
+  const opfsRoot = await navigator.storage.getDirectory();
+  const opfsHandle = await opfsRoot.getFileHandle(path, { create: true });
+  const opfsSync = await opfsHandle.createSyncAccessHandle();
+  fileHandles += 1;
+  fileByPath.set(path, { handle: fileHandles, sync: opfsSync });
+  fileByHandle.set(fileHandles, opfsSync);
+}
+
+async function unregisterFile(path) {
+  const file = fileByPath.get(path);
+  if (file == null) {
+    return;
+  }
+  fileByPath.delete(path);
+  fileByHandle.delete(file.handle);
+  file.sync.close();
+}
+
+function lookup_file(pathPtr, pathLen) {
+  try {
+    const buffer = getUint8ArrayFromWasm(pathPtr, pathLen);
+    const notShared = new Uint8Array(buffer.length);
+    notShared.set(buffer);
+    const decoder = new TextDecoder('utf-8');
+    const path = decoder.decode(notShared);
+    const file = fileByPath.get(path);
+    if (file == null) {
+      return -404;
+    }
+    return file.handle;
+  } catch (e) {
+    console.error('lookupFile', pathPtr, pathLen, e);
+    return -1;
+  }
+}
+function read(handle, bufferPtr, bufferLen, offset) {
+  try {
+    const buffer = getUint8ArrayFromWasm(bufferPtr, bufferLen);
+    const file = fileByHandle.get(Number(handle));
+    const result = file.read(buffer, { at: Number(offset) });
+    return result;
+  } catch (e) {
+    console.error('read', handle, bufferPtr, bufferLen, offset, e);
+    return -1;
+  }
+}
+function write(handle, bufferPtr, bufferLen, offset) {
+  try {
+    const buffer = getUint8ArrayFromWasm(bufferPtr, bufferLen);
+    const file = fileByHandle.get(Number(handle));
+    const result = file.write(buffer, { at: Number(offset) });
+    return result;
+  } catch (e) {
+    console.error('write', handle, bufferPtr, bufferLen, offset, e);
+    return -1;
+  }
+}
+function sync(handle) {
+  try {
+    const file = fileByHandle.get(Number(handle));
+    file.flush();
+    return 0;
+  } catch (e) {
+    console.error('sync', handle, e);
+    return -1;
+  }
+}
+function truncate(handle, size) {
+  try {
+    const file = fileByHandle.get(Number(handle));
+    const result = file.truncate(size);
+    return result;
+  } catch (e) {
+    console.error('truncate', handle, size, e);
+    return -1;
+  }
+}
+function size(handle) {
+  try {
+    const file = fileByHandle.get(Number(handle));
+    const size = file.getSize()
+    return size;
+  } catch (e) {
+    console.error('size', handle, e);
+    return -1;
+  }
+}
+
+const handler = new MessageHandler({
+  onLoad({ wasmModule, wasmMemory }) {
+    memory = wasmMemory;
+    const wasi = new WASI({
+      print: function () {
+        // eslint-disable-next-line no-console
+        console.log.apply(console, arguments)
+      },
+      printErr: function () {
+        // eslint-disable-next-line no-console
+        console.error.apply(console, arguments)
+      },
+    })
+    return instantiateNapiModuleSync(wasmModule, {
+      childThread: true,
+      wasi,
+      overwriteImports(importObject) {
+        importObject.env = {
+          ...importObject.env,
+          ...importObject.napi,
+          ...importObject.emnapi,
+          memory: wasmMemory,
+          is_web_worker: () => true,
+          lookup_file: lookup_file,
+          read: read,
+          write: write,
+          sync: sync,
+          truncate: truncate,
+          size: size,
+        }
+      },
+    })
+  },
+})
+
+globalThis.onmessage = async function (e) {
+  if (e.data.__turso__ == 'register') {
+    try {
+      await registerFile(e.data.path)
+      self.postMessage({ id: e.data.id })
+    } catch (error) {
+      self.postMessage({ id: e.data.id, error: error });
+    }
+    return;
+  } else if (e.data.__turso__ == 'unregister') {
+    try {
+      await unregisterFile(e.data.path)
+      self.postMessage({ id: e.data.id })
+    } catch (error) {
+      self.postMessage({ id: e.data.id, error: error });
+    }
+    return;
+  }
+  handler.handle(e)
+}
--- a/bindings/javascript/packages/common/README.md
+++ b/bindings/javascript/packages/common/README.md
@@ -0,0 +1,8 @@
+## About
+
+This package is the Turso embedded database common JS library which is shared between final builds for Node and Browser.
+
+Do not use this package directly - instead you must use `@tursodatabase/database` or `@tursodatabase/database-browser`.
+
+> **⚠️ Warning:** This software is ALPHA, only use for development, testing, and experimentation. We are working to make it production ready, but do not use it for critical data right now.
+
--- a/bindings/javascript/packages/common/bind.ts
+++ b/bindings/javascript/packages/common/bind.ts
--- a/bindings/javascript/packages/common/compat.ts
+++ b/bindings/javascript/packages/common/compat.ts
@@ -1,12 +1,6 @@
-import { Database as NativeDB, Statement as NativeStatement } from "#entry-point";
 import { bindParams } from "./bind.js";
-
 import { SqliteError } from "./sqlite-error.js";
-
-// Step result constants
-const STEP_ROW = 1;
-const STEP_DONE = 2;
-const STEP_IO = 3;
+import { NativeDatabase, NativeStatement, STEP_IO, STEP_ROW, STEP_DONE } from "./types.js";

 const convertibleErrorTypes = { TypeError };
 const CONVERTIBLE_ERROR_PREFIX = "[TURSO_CONVERT_TYPE]";
@@ -35,7 +29,7 @@ function createErrorByName(name, message) {
 * Database represents a connection that can prepare and execute SQL statements.
 */
 class Database {
-  db: NativeDB;
+  db: NativeDatabase;
  memory: boolean;
  open: boolean;
  private _inTransaction: boolean = false;
@@ -50,15 +44,14 @@ class Database {
   * @param {boolean} [opts.fileMustExist=false] - If true, throws if database file does not exist.
   * @param {number} [opts.timeout=0] - Timeout duration in milliseconds for database operations. Defaults to 0 (no timeout).
   */
-  constructor(path: string, opts: any = {}) {
+  constructor(db: NativeDatabase, opts: any = {}) {
    opts.readonly = opts.readonly === undefined ? false : opts.readonly;
    opts.fileMustExist =
      opts.fileMustExist === undefined ? false : opts.fileMustExist;
    opts.timeout = opts.timeout === undefined ? 0 : opts.timeout;

-    this.db = new NativeDB(path);
+    this.db = db;
    this.memory = this.db.memory;
-    const db = this.db;

    Object.defineProperties(this, {
      inTransaction: {
@@ -66,7 +59,7 @@ class Database {
      },
      name: {
        get() {
-          return path;
+          return db.path;
        },
      },
      readonly: {
@@ -199,7 +192,7 @@ class Database {
    }

    try {
-      this.db.batch(sql);
+      this.db.batchSync(sql);
    } catch (err) {
      throw convertError(err);
    }
@@ -301,7 +294,7 @@ class Statement {
    this.stmt.reset();
    bindParams(this.stmt, bindParameters);
    for (; ;) {
-      const stepResult = this.stmt.step();
+      const stepResult = this.stmt.stepSync();
      if (stepResult === STEP_IO) {
        this.db.db.ioLoopSync();
        continue;
@@ -330,7 +323,7 @@ class Statement {
    this.stmt.reset();
    bindParams(this.stmt, bindParameters);
    for (; ;) {
-      const stepResult = this.stmt.step();
+      const stepResult = this.stmt.stepSync();
      if (stepResult === STEP_IO) {
        this.db.db.ioLoopSync();
        continue;
@@ -354,7 +347,7 @@ class Statement {
    bindParams(this.stmt, bindParameters);

    while (true) {
-      const stepResult = this.stmt.step();
+      const stepResult = this.stmt.stepSync();
      if (stepResult === STEP_IO) {
        this.db.db.ioLoopSync();
        continue;
@@ -378,7 +371,7 @@ class Statement {
    bindParams(this.stmt, bindParameters);
    const rows: any[] = [];
    for (; ;) {
-      const stepResult = this.stmt.step();
+      const stepResult = this.stmt.stepSync();
      if (stepResult === STEP_IO) {
        this.db.db.ioLoopSync();
        continue;
@@ -417,4 +410,4 @@ class Statement {
  }
 }

-export { Database, SqliteError }
+export { Database, Statement }
--- a/bindings/javascript/packages/common/index.ts
+++ b/bindings/javascript/packages/common/index.ts
@@ -0,0 +1,6 @@
+import { NativeDatabase, NativeStatement, DatabaseOpts } from "./types.js";
+import { Database as DatabaseCompat, Statement as StatementCompat } from "./compat.js";
+import { Database as DatabasePromise, Statement as StatementPromise } from "./promise.js";
+import { SqliteError } from "./sqlite-error.js";
+
+export { DatabaseCompat, StatementCompat, DatabasePromise, StatementPromise, NativeDatabase, NativeStatement, SqliteError, DatabaseOpts }
--- a/bindings/javascript/packages/common/package.json
+++ b/bindings/javascript/packages/common/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "@tursodatabase/database-common",
+  "version": "0.1.5-pre.3",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tursodatabase/turso"
+  },
+  "type": "module",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "packageManager": "yarn@4.9.2",
+  "files": [
+    "dist/**",
+    "README.md"
+  ],
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "tsc-build": "npm exec tsc",
+    "build": "npm run tsc-build",
+    "test": "echo 'no tests'"
+  }
+}
--- a/bindings/javascript/packages/common/promise.ts
+++ b/bindings/javascript/packages/common/promise.ts
@@ -1,12 +1,6 @@
-import { Database as NativeDB, Statement as NativeStatement } from "#entry-point";
 import { bindParams } from "./bind.js";
-
 import { SqliteError } from "./sqlite-error.js";
-
-// Step result constants
-const STEP_ROW = 1;
-const STEP_DONE = 2;
-const STEP_IO = 3;
+import { NativeDatabase, NativeStatement, STEP_IO, STEP_ROW, STEP_DONE, DatabaseOpts } from "./types.js";

 const convertibleErrorTypes = { TypeError };
 const CONVERTIBLE_ERROR_PREFIX = "[TURSO_CONVERT_TYPE]";
@@ -35,7 +29,7 @@ function createErrorByName(name, message) {
 * Database represents a connection that can prepare and execute SQL statements.
 */
 class Database {
-  db: NativeDB;
+  db: NativeDatabase;
  memory: boolean;
  open: boolean;
  private _inTransaction: boolean = false;
@@ -49,19 +43,18 @@ class Database {
   * @param {boolean} [opts.fileMustExist=false] - If true, throws if database file does not exist.
   * @param {number} [opts.timeout=0] - Timeout duration in milliseconds for database operations. Defaults to 0 (no timeout).
   */
-  constructor(path: string, opts: any = {}) {
+  constructor(db: NativeDatabase, opts: DatabaseOpts = {}) {
    opts.readonly = opts.readonly === undefined ? false : opts.readonly;
    opts.fileMustExist =
      opts.fileMustExist === undefined ? false : opts.fileMustExist;
    opts.timeout = opts.timeout === undefined ? 0 : opts.timeout;

-    const db = new NativeDB(path);
-    this.initialize(db, opts.path, opts.readonly);
+    this.initialize(db, opts.name, opts.readonly);
  }
  static create() {
    return Object.create(this.prototype);
  }
-  initialize(db: NativeDB, name, readonly) {
+  initialize(db: NativeDatabase, name, readonly) {
    this.db = db;
    this.memory = db.memory;
    Object.defineProperties(this, {
@@ -112,22 +105,22 @@ class Database {
   *
   * @param {function} fn - The function to wrap in a transaction.
   */
-  transaction(fn) {
+  transaction(fn: (...any) => Promise<any>) {
    if (typeof fn !== "function")
      throw new TypeError("Expected first argument to be a function");

    const db = this;
    const wrapTxn = (mode) => {
-      return (...bindParameters) => {
-        db.exec("BEGIN " + mode);
+      return async (...bindParameters) => {
+        await db.exec("BEGIN " + mode);
        db._inTransaction = true;
        try {
-          const result = fn(...bindParameters);
-          db.exec("COMMIT");
+          const result = await fn(...bindParameters);
+          await db.exec("COMMIT");
          db._inTransaction = false;
          return result;
        } catch (err) {
-          db.exec("ROLLBACK");
+          await db.exec("ROLLBACK");
          db._inTransaction = false;
          throw err;
        }
@@ -147,7 +140,7 @@ class Database {
    return properties.default.value;
  }

-  pragma(source, options) {
+  async pragma(source, options) {
    if (options == null) options = {};

    if (typeof source !== "string")
@@ -158,8 +151,8 @@ class Database {

    const pragma = `PRAGMA ${source}`;

-    const stmt = this.prepare(pragma);
-    const results = stmt.all();
+    const stmt = await this.prepare(pragma);
+    const results = await stmt.all();

    return results;
  }
@@ -197,13 +190,13 @@ class Database {
   *
   * @param {string} sql - The SQL statement string to execute.
   */
-  exec(sql) {
+  async exec(sql) {
    if (!this.open) {
      throw new TypeError("The database connection is not open");
    }

    try {
-      this.db.batch(sql);
+      await this.db.batchAsync(sql);
    } catch (err) {
      throw convertError(err);
    }
@@ -228,7 +221,7 @@ class Database {
  /**
   * Closes the database connection.
   */
-  close() {
+  async close() {
    this.db.close();
  }
 }
@@ -305,7 +298,7 @@ class Statement {
    bindParams(this.stmt, bindParameters);

    while (true) {
-      const stepResult = this.stmt.step();
+      const stepResult = await this.stmt.stepAsync();
      if (stepResult === STEP_IO) {
        await this.db.db.ioLoopAsync();
        continue;
@@ -335,7 +328,7 @@ class Statement {
    bindParams(this.stmt, bindParameters);

    while (true) {
-      const stepResult = this.stmt.step();
+      const stepResult = await this.stmt.stepAsync();
      if (stepResult === STEP_IO) {
        await this.db.db.ioLoopAsync();
        continue;
@@ -359,7 +352,7 @@ class Statement {
    bindParams(this.stmt, bindParameters);

    while (true) {
-      const stepResult = this.stmt.step();
+      const stepResult = await this.stmt.stepAsync();
      if (stepResult === STEP_IO) {
        await this.db.db.ioLoopAsync();
        continue;
@@ -384,7 +377,7 @@ class Statement {
    const rows: any[] = [];

    while (true) {
-      const stepResult = this.stmt.step();
+      const stepResult = await this.stmt.stepAsync();
      if (stepResult === STEP_IO) {
        await this.db.db.ioLoopAsync();
        continue;
@@ -421,17 +414,9 @@ class Statement {
      throw convertError(err);
    }
  }
-}

-/**
- * Creates a new database connection asynchronously.
- * 
- * @param {string} path - Path to the database file.
- * @param {Object} opts - Options for database behavior.
- * @returns {Promise<Database>} - A promise that resolves to a Database instance.
- */
-async function connect(path: string, opts: any = {}): Promise<Database> {
-  return new Database(path, opts);
+  close() {
+    this.stmt.finalize();
+  }
 }
-
-export { Database, SqliteError, connect }
+export { Database, Statement }
--- a/bindings/javascript/packages/common/sqlite-error.ts
+++ b/bindings/javascript/packages/common/sqlite-error.ts
--- a/bindings/javascript/packages/common/tsconfig.json
+++ b/bindings/javascript/packages/common/tsconfig.json
@@ -1,17 +1,14 @@
 {
  "compilerOptions": {
    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
    "module": "esnext",
    "target": "esnext",
    "outDir": "dist/",
    "lib": [
      "es2020"
    ],
-    "paths": {
-      "#entry-point": [
-        "./index.js"
-      ]
-    }
  },
  "include": [
    "*"
--- a/bindings/javascript/packages/common/types.ts
+++ b/bindings/javascript/packages/common/types.ts
@@ -0,0 +1,46 @@
+export interface DatabaseOpts {
+    readonly?: boolean,
+    fileMustExist?: boolean,
+    timeout?: number
+    name?: string
+    tracing?: 'info' | 'debug' | 'trace'
+}
+
+export interface NativeDatabase {
+    memory: boolean,
+    path: string,
+    new(path: string): NativeDatabase;
+    batchSync(sql: string);
+    batchAsync(sql: string): Promise<void>;
+
+    ioLoopSync();
+    ioLoopAsync(): Promise<void>;
+
+    prepare(sql: string): NativeStatement;
+
+    pluck(pluckMode: boolean);
+    defaultSafeIntegers(toggle: boolean);
+    totalChanges(): number;
+    changes(): number;
+    lastInsertRowid(): number;
+    close();
+}
+
+
+// Step result constants
+export const STEP_ROW = 1;
+export const STEP_DONE = 2;
+export const STEP_IO = 3;
+
+export interface NativeStatement {
+    stepAsync(): Promise<number>;
+    stepSync(): number;
+
+    pluck(pluckMode: boolean);
+    safeIntegers(toggle: boolean);
+    raw(toggle: boolean);
+    columns(): string[];
+    row(): any;
+    reset();
+    finalize();
+}
--- a/bindings/javascript/packages/native/README.md
+++ b/bindings/javascript/packages/native/README.md
@@ -0,0 +1,125 @@
+<p align="center">
+  <h1 align="center">Turso Database for JavaScript in Node</h1>
+</p>
+
+<p align="center">
+  <a title="JavaScript" target="_blank" href="https://www.npmjs.com/package/@tursodatabase/database"><img alt="npm" src="https://img.shields.io/npm/v/@tursodatabase/database"></a>
+  <a title="MIT" target="_blank" href="https://github.com/tursodatabase/turso/blob/main/LICENSE.md"><img src="http://img.shields.io/badge/license-MIT-orange.svg?style=flat-square"></a>
+</p>
+<p align="center">
+  <a title="Users Discord" target="_blank" href="https://tur.so/discord"><img alt="Chat with other users of Turso on Discord" src="https://img.shields.io/discord/933071162680958986?label=Discord&logo=Discord&style=social"></a>
+</p>
+
+---
+
+## About
+
+This package is the Turso embedded database library for JavaScript in Node.
+
+> **⚠️ Warning:** This software is ALPHA, only use for development, testing, and experimentation. We are working to make it production ready, but do not use it for critical data right now.
+
+## Features
+
+- **SQLite compatible:** SQLite query language and file format support ([status](https://github.com/tursodatabase/turso/blob/main/COMPAT.md)).
+- **In-process**: No network overhead, runs directly in your Node.js process
+- **TypeScript support**: Full TypeScript definitions included
+- **Cross-platform**: Supports Linux (x86 and arm64), macOS, Windows (browser is supported in the separate package `@tursodatabase/database-browser` package)
+
+## Installation
+
+```bash
+npm install @tursodatabase/database
+```
+
+## Getting Started
+
+### In-Memory Database
+
+```javascript
+import { connect } from '@tursodatabase/database';
+
+// Create an in-memory database
+const db = await connect(':memory:');
+
+// Create a table
+await db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)');
+
+// Insert data
+const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+await insert.run('Alice', 'alice@example.com');
+await insert.run('Bob', 'bob@example.com');
+
+// Query data
+const users = await db.prepare('SELECT * FROM users').all();
+console.log(users);
+// Output: [
+//   { id: 1, name: 'Alice', email: 'alice@example.com' },
+//   { id: 2, name: 'Bob', email: 'bob@example.com' }
+// ]
+```
+
+### File-Based Database
+
+```javascript
+import { connect } from '@tursodatabase/database';
+
+// Create or open a database file
+const db = await connect('my-database.db');
+
+// Create a table
+await db.exec(`
+  CREATE TABLE IF NOT EXISTS posts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    content TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  )
+`);
+
+// Insert a post
+const insertPost = db.prepare('INSERT INTO posts (title, content) VALUES (?, ?)');
+const result = await insertPost.run('Hello World', 'This is my first blog post!');
+
+console.log(`Inserted post with ID: ${result.lastInsertRowid}`);
+```
+
+### Transactions
+
+```javascript
+import { connect } from '@tursodatabase/database';
+
+const db = await connect('transactions.db');
+
+// Using transactions for atomic operations
+const transaction = db.transaction(async (users) => {
+  const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+  for (const user of users) {
+    await insert.run(user.name, user.email);
+  }
+});
+
+// Execute transaction
+await transaction([
+  { name: 'Alice', email: 'alice@example.com' },
+  { name: 'Bob', email: 'bob@example.com' }
+]);
+```
+
+## API Reference
+
+For complete API documentation, see [JavaScript API Reference](../../../../docs/javascript-api-reference.md).
+
+## Related Packages
+
+* The [@tursodatabase/serverless](https://www.npmjs.com/package/@tursodatabase/serverless) package provides a serverless driver with the same API.
+* The [@tursodatabase/sync](https://www.npmjs.com/package/@tursodatabase/sync) package provides bidirectional sync between a local Turso database and Turso Cloud. 
+
+## License
+
+This project is licensed under the [MIT license](../../LICENSE.md).
+
+## Support
+
+- [GitHub Issues](https://github.com/tursodatabase/turso/issues)
+- [Documentation](https://docs.turso.tech)
+- [Discord Community](https://tur.so/discord)
--- a/bindings/javascript/packages/native/compat.test.ts
+++ b/bindings/javascript/packages/native/compat.test.ts
@@ -0,0 +1,67 @@
+import { unlinkSync } from "node:fs";
+import { expect, test } from 'vitest'
+import { Database } from './compat.js'
+
+test('in-memory db', () => {
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE t(x)");
+    db.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const stmt = db.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    const rows = stmt.all([1]);
+    expect(rows).toEqual([{ x: 1 }, { x: 3 }]);
+})
+
+test('on-disk db', () => {
+    const path = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        const db1 = new Database(path);
+        db1.exec("CREATE TABLE t(x)");
+        db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+        const stmt1 = db1.prepare("SELECT * FROM t WHERE x % 2 = ?");
+        expect(stmt1.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows1 = stmt1.all([1]);
+        expect(rows1).toEqual([{ x: 1 }, { x: 3 }]);
+        db1.close();
+
+        const db2 = new Database(path);
+        const stmt2 = db2.prepare("SELECT * FROM t WHERE x % 2 = ?");
+        expect(stmt2.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows2 = stmt2.all([1]);
+        expect(rows2).toEqual([{ x: 1 }, { x: 3 }]);
+        db2.close();
+    } finally {
+        unlinkSync(path);
+        unlinkSync(`${path}-wal`);
+    }
+})
+
+test('attach', () => {
+    const path1 = `test-${(Math.random() * 10000) | 0}.db`;
+    const path2 = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        const db1 = new Database(path1);
+        db1.exec("CREATE TABLE t(x)");
+        db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+        const db2 = new Database(path2);
+        db2.exec("CREATE TABLE q(x)");
+        db2.exec("INSERT INTO q VALUES (4), (5), (6)");
+
+        db1.exec(`ATTACH '${path2}' as secondary`);
+
+        const stmt = db1.prepare("SELECT * FROM t UNION ALL SELECT * FROM secondary.q");
+        expect(stmt.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows = stmt.all([1]);
+        expect(rows).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 4 }, { x: 5 }, { x: 6 }]);
+    } finally {
+        unlinkSync(path1);
+        unlinkSync(`${path1}-wal`);
+        unlinkSync(path2);
+        unlinkSync(`${path2}-wal`);
+    }
+})
+
+test('blobs', () => {
+    const db = new Database(":memory:");
+    const rows = db.prepare("SELECT x'1020' as x").all();
+    expect(rows).toEqual([{ x: Buffer.from([16, 32]) }])
+})
--- a/bindings/javascript/packages/native/compat.ts
+++ b/bindings/javascript/packages/native/compat.ts
@@ -0,0 +1,10 @@
+import { DatabaseCompat, NativeDatabase, SqliteError, DatabaseOpts } from "@tursodatabase/database-common"
+import { Database as NativeDB } from "#index";
+
+class Database extends DatabaseCompat {
+    constructor(path: string, opts: DatabaseOpts = {}) {
+        super(new NativeDB(path, { tracing: opts.tracing }) as unknown as NativeDatabase, opts)
+    }
+}
+
+export { Database, SqliteError }
--- a/bindings/javascript/packages/native/index.d.ts
+++ b/bindings/javascript/packages/native/index.d.ts
@@ -8,13 +8,13 @@ export declare class Database {
   * # Arguments
   * * `path` - The path to the database file.
   */
-  constructor(path: string)
+  constructor(path: string, opts?: DatabaseOpts | undefined | null)
  /** Returns whether the database is in memory-only mode. */
  get memory(): boolean
  /** Returns whether the database connection is open. */
  get open(): boolean
  /**
-   * Executes a batch of SQL statements.
+   * Executes a batch of SQL statements on main thread
   *
   * # Arguments
   *
@@ -22,7 +22,17 @@ export declare class Database {
   *
   * # Returns
   */
-  batch(sql: string): void
+  batchSync(sql: string): void
+  /**
+   * Executes a batch of SQL statements outside of main thread
+   *
+   * # Arguments
+   *
+   * * `sql` - The SQL statements to execute.
+   *
+   * # Returns
+   */
+  batchAsync(sql: string): Promise<unknown>
  /**
   * Prepares a statement for execution.
   *
@@ -105,10 +115,15 @@ export declare class Statement {
   */
  bindAt(index: number, value: unknown): void
  /**
-   * Step the statement and return result code:
+   * Step the statement and return result code (executed on the main thread):
   * 1 = Row available, 2 = Done, 3 = I/O needed
   */
-  step(): number
+  stepSync(): number
+  /**
+   * Step the statement and return result code (executed on the background thread):
+   * 1 = Row available, 2 = Done, 3 = I/O needed
+   */
+  stepAsync(): Promise<unknown>
  /** Get the current row data according to the presentation mode */
  row(): unknown
  /** Sets the presentation mode to raw. */
@@ -128,3 +143,7 @@ export declare class Statement {
  /** Finalizes the statement. */
  finalize(): void
 }
+
+export interface DatabaseOpts {
+  tracing?: string
+}
--- a/bindings/javascript/packages/native/index.js
+++ b/bindings/javascript/packages/native/index.js
@@ -0,0 +1,513 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+const __dirname = new URL('.', import.meta.url).pathname
+
+const { readFileSync } = require('node:fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      nativeBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./turso.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-android-arm64')
+        const bindingPackageVersion = require('@tursodatabase/database-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./turso.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-android-arm-eabi')
+        const bindingPackageVersion = require('@tursodatabase/database-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-win32-x64-msvc')
+        const bindingPackageVersion = require('@tursodatabase/database-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./turso.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-win32-ia32-msvc')
+        const bindingPackageVersion = require('@tursodatabase/database-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./turso.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-win32-arm64-msvc')
+        const bindingPackageVersion = require('@tursodatabase/database-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./turso.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('@tursodatabase/database-darwin-universal')
+      const bindingPackageVersion = require('@tursodatabase/database-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-darwin-x64')
+        const bindingPackageVersion = require('@tursodatabase/database-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./turso.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-darwin-arm64')
+        const bindingPackageVersion = require('@tursodatabase/database-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-freebsd-x64')
+        const bindingPackageVersion = require('@tursodatabase/database-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./turso.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-freebsd-arm64')
+        const bindingPackageVersion = require('@tursodatabase/database-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-x64-musl')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-x64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-arm64-musl')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-arm64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-riscv64-musl')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/database-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/database-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./turso.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@tursodatabase/database-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./turso.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-linux-s390x-gnu')
+        const bindingPackageVersion = require('@tursodatabase/database-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./turso.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-openharmony-arm64')
+        const bindingPackageVersion = require('@tursodatabase/database-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./turso.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-openharmony-x64')
+        const bindingPackageVersion = require('@tursodatabase/database-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./turso.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/database-openharmony-arm')
+        const bindingPackageVersion = require('@tursodatabase/database-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.1.5-pre.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5-pre.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  try {
+    nativeBinding = require('./turso.wasi.cjs')
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      loadErrors.push(err)
+    }
+  }
+  if (!nativeBinding) {
+    try {
+      nativeBinding = require('@tursodatabase/database-wasm32-wasi')
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err)
+      }
+    }
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+      { cause: loadErrors }
+    )
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { Database, Statement } = nativeBinding
+export { Database }
+export { Statement }
--- a/bindings/javascript/packages/native/package.json
+++ b/bindings/javascript/packages/native/package.json
@@ -0,0 +1,52 @@
+{
+  "name": "@tursodatabase/database",
+  "version": "0.1.5-pre.3",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tursodatabase/turso"
+  },
+  "license": "MIT",
+  "module": "./dist/promise.js",
+  "main": "./dist/promise.js",
+  "type": "module",
+  "exports": {
+    ".": "./dist/promise.js",
+    "./compat": "./dist/compat.js"
+  },
+  "files": [
+    "index.js",
+    "dist/**",
+    "README.md"
+  ],
+  "packageManager": "yarn@4.9.2",
+  "devDependencies": {
+    "@napi-rs/cli": "^3.1.5",
+    "@types/node": "^24.3.1",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "napi-build": "napi build --platform --release --esm --manifest-path ../../Cargo.toml --output-dir .",
+    "napi-dirs": "napi create-npm-dirs",
+    "napi-artifacts": "napi artifacts --output-dir .",
+    "tsc-build": "npm exec tsc",
+    "build": "npm run napi-build && npm run tsc-build",
+    "test": "vitest --run",
+    "prepublishOnly": "npm run napi-dirs && npm run napi-artifacts && napi prepublish -t npm"
+  },
+  "napi": {
+    "binaryName": "turso",
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc",
+      "universal-apple-darwin",
+      "aarch64-unknown-linux-gnu"
+    ]
+  },
+  "dependencies": {
+    "@tursodatabase/database-common": "^0.1.5-pre.3"
+  },
+  "imports": {
+    "#index": "./index.js"
+  }
+}
--- a/bindings/javascript/packages/native/promise.test.ts
+++ b/bindings/javascript/packages/native/promise.test.ts
@@ -0,0 +1,107 @@
+import { unlinkSync } from "node:fs";
+import { expect, test } from 'vitest'
+import { connect } from './promise.js'
+
+test('in-memory db', async () => {
+    const db = await connect(":memory:");
+    await db.exec("CREATE TABLE t(x)");
+    await db.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const stmt = db.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    const rows = await stmt.all([1]);
+    expect(rows).toEqual([{ x: 1 }, { x: 3 }]);
+})
+
+test('on-disk db', async () => {
+    const path = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        const db1 = await connect(path);
+        await db1.exec("CREATE TABLE t(x)");
+        await db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+        const stmt1 = db1.prepare("SELECT * FROM t WHERE x % 2 = ?");
+        expect(stmt1.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows1 = await stmt1.all([1]);
+        expect(rows1).toEqual([{ x: 1 }, { x: 3 }]);
+        db1.close();
+
+        const db2 = await connect(path);
+        const stmt2 = db2.prepare("SELECT * FROM t WHERE x % 2 = ?");
+        expect(stmt2.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows2 = await stmt2.all([1]);
+        expect(rows2).toEqual([{ x: 1 }, { x: 3 }]);
+        db2.close();
+    } finally {
+        unlinkSync(path);
+        unlinkSync(`${path}-wal`);
+    }
+})
+
+test('attach', async () => {
+    const path1 = `test-${(Math.random() * 10000) | 0}.db`;
+    const path2 = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        const db1 = await connect(path1);
+        await db1.exec("CREATE TABLE t(x)");
+        await db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+        const db2 = await connect(path2);
+        await db2.exec("CREATE TABLE q(x)");
+        await db2.exec("INSERT INTO q VALUES (4), (5), (6)");
+
+        await db1.exec(`ATTACH '${path2}' as secondary`);
+
+        const stmt = db1.prepare("SELECT * FROM t UNION ALL SELECT * FROM secondary.q");
+        expect(stmt.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows = await stmt.all([1]);
+        expect(rows).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 4 }, { x: 5 }, { x: 6 }]);
+    } finally {
+        unlinkSync(path1);
+        unlinkSync(`${path1}-wal`);
+        unlinkSync(path2);
+        unlinkSync(`${path2}-wal`);
+    }
+})
+
+test('blobs', async () => {
+    const db = await connect(":memory:");
+    const rows = await db.prepare("SELECT x'1020' as x").all();
+    expect(rows).toEqual([{ x: Buffer.from([16, 32]) }])
+})
+
+
+test('example-1', async () => {
+    const db = await connect(':memory:');
+    await db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)');
+
+    const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+    await insert.run('Alice', 'alice@example.com');
+    await insert.run('Bob', 'bob@example.com');
+
+    const users = await db.prepare('SELECT * FROM users').all();
+    expect(users).toEqual([
+        { id: 1, name: 'Alice', email: 'alice@example.com' },
+        { id: 2, name: 'Bob', email: 'bob@example.com' }
+    ]);
+})
+
+test('example-2', async () => {
+    const db = await connect(':memory:');
+    await db.exec('CREATE TABLE users (name, email)');
+    // Using transactions for atomic operations
+    const transaction = db.transaction(async (users) => {
+        const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+        for (const user of users) {
+            await insert.run(user.name, user.email);
+        }
+    });
+
+    // Execute transaction
+    await transaction([
+        { name: 'Alice', email: 'alice@example.com' },
+        { name: 'Bob', email: 'bob@example.com' }
+    ]);
+
+    const rows = await db.prepare('SELECT * FROM users').all();
+    expect(rows).toEqual([
+        { name: 'Alice', email: 'alice@example.com' },
+        { name: 'Bob', email: 'bob@example.com' }
+    ]);
+})
--- a/bindings/javascript/packages/native/promise.ts
+++ b/bindings/javascript/packages/native/promise.ts
@@ -0,0 +1,21 @@
+import { DatabasePromise, NativeDatabase, SqliteError, DatabaseOpts } from "@tursodatabase/database-common"
+import { Database as NativeDB } from "#index";
+
+class Database extends DatabasePromise {
+    constructor(path: string, opts: DatabaseOpts = {}) {
+        super(new NativeDB(path, { tracing: opts.tracing }) as unknown as NativeDatabase, opts)
+    }
+}
+
+/**
+ * Creates a new database connection asynchronously.
+ * 
+ * @param {string} path - Path to the database file.
+ * @param {Object} opts - Options for database behavior.
+ * @returns {Promise<Database>} - A promise that resolves to a Database instance.
+ */
+async function connect(path: string, opts: any = {}): Promise<Database> {
+    return new Database(path, opts);
+}
+
+export { connect, Database, SqliteError }
--- a/bindings/javascript/packages/native/tsconfig.json
+++ b/bindings/javascript/packages/native/tsconfig.json
@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "module": "nodenext",
+    "target": "esnext",
+    "outDir": "dist/",
+    "lib": [
+      "es2020"
+    ],
+    "paths": {
+      "#index": [
+        "./index.js"
+      ]
+    }
+  },
+  "include": [
+    "*"
+  ]
+}
--- a/bindings/javascript/perf/package-lock.json
+++ b/bindings/javascript/perf/package-lock.json
@@ -6,28 +6,34 @@
    "": {
      "name": "turso-perf",
      "dependencies": {
-        "@tursodatabase/database": "..",
+        "@tursodatabase/database": "../packages/native",
        "better-sqlite3": "^9.5.0",
        "mitata": "^0.1.11"
      }
    },
    "..": {
+      "workspaces": [
+        "packages/core",
+        "packages/native",
+        "packages/browser"
+      ]
+    },
+    "../packages/native": {
      "name": "@tursodatabase/database",
-      "version": "0.1.4-pre.4",
+      "version": "0.1.5-pre.3",
      "license": "MIT",
-      "devDependencies": {
-        "@napi-rs/cli": "^3.0.4",
-        "@napi-rs/wasm-runtime": "^1.0.1",
-        "ava": "^6.0.1",
-        "better-sqlite3": "^11.9.1",
-        "typescript": "^5.9.2"
+      "dependencies": {
+        "@tursodatabase/database-common": "^0.1.5-pre.3"
      },
-      "engines": {
-        "node": ">= 10"
+      "devDependencies": {
+        "@napi-rs/cli": "^3.1.5",
+        "@types/node": "^24.3.1",
+        "typescript": "^5.9.2",
+        "vitest": "^3.2.4"
      }
    },
    "node_modules/@tursodatabase/database": {
-      "resolved": "..",
+      "resolved": "../packages/native",
      "link": true
    },
    "node_modules/base64-js": {
--- a/bindings/javascript/perf/package.json
+++ b/bindings/javascript/perf/package.json
@@ -2,9 +2,10 @@
  "name": "turso-perf",
  "type": "module",
  "private": true,
+  "type": "module",
  "dependencies": {
    "better-sqlite3": "^9.5.0",
-    "@tursodatabase/database": "..",
+    "@tursodatabase/database": "../packages/native",
    "mitata": "^0.1.11"
  }
 }
--- a/bindings/javascript/perf/perf-turso.js
+++ b/bindings/javascript/perf/perf-turso.js
@@ -1,6 +1,6 @@
 import { run, bench, group, baseline } from 'mitata';

-import Database from '@tursodatabase/database';
+import { Database } from '@tursodatabase/database/compat';

 const db = new Database(':memory:');

--- a/bindings/javascript/src/browser.rs
+++ b/bindings/javascript/src/browser.rs
@@ -0,0 +1,254 @@
+use std::sync::Arc;
+
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use turso_core::{storage::database::DatabaseFile, Clock, File, Instant, IO};
+
+use crate::{init_tracing, is_memory, Database, DatabaseOpts};
+
+pub struct NoopTask;
+
+impl Task for NoopTask {
+    type Output = ();
+    type JsValue = ();
+    fn compute(&mut self) -> Result<Self::Output> {
+        Ok(())
+    }
+    fn resolve(&mut self, _: Env, _: Self::Output) -> Result<Self::JsValue> {
+        Ok(())
+    }
+}
+
+#[napi]
+/// turso-db in the the browser requires explicit thread pool initialization
+/// so, we just put no-op task on the thread pool and force emnapi to allocate web worker
+pub fn init_thread_pool() -> napi::Result<AsyncTask<NoopTask>> {
+    Ok(AsyncTask::new(NoopTask))
+}
+
+pub struct ConnectTask {
+    path: String,
+    is_memory: bool,
+    io: Arc<dyn turso_core::IO>,
+}
+
+pub struct ConnectResult {
+    db: Arc<turso_core::Database>,
+    conn: Arc<turso_core::Connection>,
+}
+
+unsafe impl Send for ConnectResult {}
+
+impl Task for ConnectTask {
+    type Output = ConnectResult;
+    type JsValue = Database;
+
+    fn compute(&mut self) -> Result<Self::Output> {
+        let file = self
+            .io
+            .open_file(&self.path, turso_core::OpenFlags::Create, false)
+            .map_err(|e| Error::new(Status::GenericFailure, format!("Failed to open file: {e}")))?;
+
+        let db_file = Arc::new(DatabaseFile::new(file));
+        let db = turso_core::Database::open(self.io.clone(), &self.path, db_file, false, true)
+            .map_err(|e| {
+                Error::new(
+                    Status::GenericFailure,
+                    format!("Failed to open database: {e}"),
+                )
+            })?;
+
+        let conn = db
+            .connect()
+            .map_err(|e| Error::new(Status::GenericFailure, format!("Failed to connect: {e}")))?;
+
+        Ok(ConnectResult { db, conn })
+    }
+
+    fn resolve(&mut self, _: Env, result: Self::Output) -> Result<Self::JsValue> {
+        Ok(Database::create(
+            Some(result.db),
+            self.io.clone(),
+            result.conn,
+            self.is_memory,
+        ))
+    }
+}
+
+#[napi]
+// we offload connect to the web-worker because:
+// 1. browser main-thread do not support Atomic.wait operations
+// 2. turso-db use blocking IO [io.wait_for_completion(c)] in few places during initialization path
+//
+// so, we offload connect to the worker thread
+pub fn connect(path: String, opts: Option<DatabaseOpts>) -> Result<AsyncTask<ConnectTask>> {
+    if let Some(opts) = opts {
+        init_tracing(opts.tracing);
+    }
+    let task = if is_memory(&path) {
+        ConnectTask {
+            io: Arc::new(turso_core::MemoryIO::new()),
+            is_memory: true,
+            path,
+        }
+    } else {
+        let io = Arc::new(Opfs::new()?);
+        ConnectTask {
+            io,
+            is_memory: false,
+            path,
+        }
+    };
+    Ok(AsyncTask::new(task))
+}
+#[napi]
+#[derive(Clone)]
+pub struct Opfs;
+
+#[napi]
+#[derive(Clone)]
+struct OpfsFile {
+    handle: i32,
+}
+
+#[napi]
+impl Opfs {
+    #[napi(constructor)]
+    pub fn new() -> napi::Result<Self> {
+        Ok(Self)
+    }
+}
+
+impl Clock for Opfs {
+    fn now(&self) -> Instant {
+        Instant { secs: 0, micros: 0 } // TODO
+    }
+}
+
+#[link(wasm_import_module = "env")]
+extern "C" {
+    fn lookup_file(path: *const u8, path_len: usize) -> i32;
+    fn read(handle: i32, buffer: *mut u8, buffer_len: usize, offset: i32) -> i32;
+    fn write(handle: i32, buffer: *const u8, buffer_len: usize, offset: i32) -> i32;
+    fn sync(handle: i32) -> i32;
+    fn truncate(handle: i32, length: usize) -> i32;
+    fn size(handle: i32) -> i32;
+    fn is_web_worker() -> bool;
+}
+
+fn is_web_worker_safe() -> bool {
+    unsafe { is_web_worker() }
+}
+
+impl IO for Opfs {
+    fn open_file(
+        &self,
+        path: &str,
+        _: turso_core::OpenFlags,
+        _: bool,
+    ) -> turso_core::Result<std::sync::Arc<dyn turso_core::File>> {
+        tracing::info!("open_file: {}", path);
+        let result = unsafe { lookup_file(path.as_ptr(), path.len()) };
+        if result >= 0 {
+            Ok(Arc::new(OpfsFile { handle: result }))
+        } else if result == -404 {
+            Err(turso_core::LimboError::InternalError(
+                "files must be created in advance for OPFS IO".to_string(),
+            ))
+        } else {
+            Err(turso_core::LimboError::InternalError(format!(
+                "unexpected file lookup error: {result}"
+            )))
+        }
+    }
+
+    fn remove_file(&self, _: &str) -> turso_core::Result<()> {
+        Ok(())
+    }
+}
+
+impl File for OpfsFile {
+    fn lock_file(&self, _: bool) -> turso_core::Result<()> {
+        Ok(())
+    }
+
+    fn unlock_file(&self) -> turso_core::Result<()> {
+        Ok(())
+    }
+
+    fn pread(
+        &self,
+        pos: u64,
+        c: turso_core::Completion,
+    ) -> turso_core::Result<turso_core::Completion> {
+        assert!(
+            is_web_worker_safe(),
+            "opfs must be used only from web worker for now"
+        );
+        tracing::debug!("pread({}): pos={}", self.handle, pos);
+        let handle = self.handle;
+        let read_c = c.as_read();
+        let buffer = read_c.buf_arc();
+        let buffer = buffer.as_mut_slice();
+        let result = unsafe { read(handle, buffer.as_mut_ptr(), buffer.len(), pos as i32) };
+        c.complete(result as i32);
+        Ok(c)
+    }
+
+    fn pwrite(
+        &self,
+        pos: u64,
+        buffer: Arc<turso_core::Buffer>,
+        c: turso_core::Completion,
+    ) -> turso_core::Result<turso_core::Completion> {
+        assert!(
+            is_web_worker_safe(),
+            "opfs must be used only from web worker for now"
+        );
+        tracing::debug!("pwrite({}): pos={}", self.handle, pos);
+        let handle = self.handle;
+        let buffer = buffer.as_slice();
+        let result = unsafe { write(handle, buffer.as_ptr(), buffer.len(), pos as i32) };
+        c.complete(result as i32);
+        Ok(c)
+    }
+
+    fn sync(&self, c: turso_core::Completion) -> turso_core::Result<turso_core::Completion> {
+        assert!(
+            is_web_worker_safe(),
+            "opfs must be used only from web worker for now"
+        );
+        tracing::debug!("sync({})", self.handle);
+        let handle = self.handle;
+        let result = unsafe { sync(handle) };
+        c.complete(result as i32);
+        Ok(c)
+    }
+
+    fn truncate(
+        &self,
+        len: u64,
+        c: turso_core::Completion,
+    ) -> turso_core::Result<turso_core::Completion> {
+        assert!(
+            is_web_worker_safe(),
+            "opfs must be used only from web worker for now"
+        );
+        tracing::debug!("truncate({}): len={}", self.handle, len);
+        let handle = self.handle;
+        let result = unsafe { truncate(handle, len as usize) };
+        c.complete(result as i32);
+        Ok(c)
+    }
+
+    fn size(&self) -> turso_core::Result<u64> {
+        assert!(
+            is_web_worker_safe(),
+            "size can be called only from web worker context"
+        );
+        tracing::debug!("size({})", self.handle);
+        let handle = self.handle;
+        let result = unsafe { size(handle) };
+        Ok(result as u64)
+    }
+}
--- a/bindings/javascript/src/lib.rs
+++ b/bindings/javascript/src/lib.rs
@@ -10,14 +10,20 @@
 //! - Iterating through query results
 //! - Managing the I/O event loop

+#[cfg(feature = "browser")]
+pub mod browser;
+
 use napi::bindgen_prelude::*;
 use napi::{Env, Task};
 use napi_derive::napi;
+use std::sync::OnceLock;
 use std::{
    cell::{Cell, RefCell},
    num::NonZeroUsize,
    sync::Arc,
 };
+use tracing_subscriber::filter::LevelFilter;
+use tracing_subscriber::fmt::format::FmtSpan;

 /// Step result constants
 const STEP_ROW: u32 = 1;
@@ -38,12 +44,107 @@ enum PresentationMode {
 pub struct Database {
    _db: Option<Arc<turso_core::Database>>,
    io: Arc<dyn turso_core::IO>,
-    conn: Arc<turso_core::Connection>,
+    conn: Option<Arc<turso_core::Connection>>,
    is_memory: bool,
    is_open: Cell<bool>,
    default_safe_integers: Cell<bool>,
 }

+pub(crate) fn is_memory(path: &str) -> bool {
+    path == ":memory:"
+}
+
+static TRACING_INIT: OnceLock<()> = OnceLock::new();
+pub(crate) fn init_tracing(level_filter: Option<String>) {
+    let Some(level_filter) = level_filter else {
+        return;
+    };
+    let level_filter = match level_filter.as_ref() {
+        "info" => LevelFilter::INFO,
+        "debug" => LevelFilter::DEBUG,
+        "trace" => LevelFilter::TRACE,
+        _ => return,
+    };
+    TRACING_INIT.get_or_init(|| {
+        tracing_subscriber::fmt()
+            .with_ansi(false)
+            .with_thread_ids(true)
+            .with_span_events(FmtSpan::ACTIVE)
+            .with_max_level(level_filter)
+            .init();
+    });
+}
+
+pub enum DbTask {
+    Batch {
+        conn: Arc<turso_core::Connection>,
+        sql: String,
+    },
+    Step {
+        stmt: Arc<RefCell<Option<turso_core::Statement>>>,
+    },
+}
+
+unsafe impl Send for DbTask {}
+
+impl Task for DbTask {
+    type Output = u32;
+    type JsValue = u32;
+
+    fn compute(&mut self) -> Result<Self::Output> {
+        match self {
+            DbTask::Batch { conn, sql } => {
+                batch_sync(conn, sql)?;
+                Ok(0)
+            }
+            DbTask::Step { stmt } => step_sync(stmt),
+        }
+    }
+
+    fn resolve(&mut self, _: Env, output: Self::Output) -> Result<Self::JsValue> {
+        Ok(output)
+    }
+}
+
+#[napi(object)]
+pub struct DatabaseOpts {
+    pub tracing: Option<String>,
+}
+
+fn batch_sync(conn: &Arc<turso_core::Connection>, sql: &str) -> napi::Result<()> {
+    conn.prepare_execute_batch(sql).map_err(|e| {
+        Error::new(
+            Status::GenericFailure,
+            format!("Failed to execute batch: {e}"),
+        )
+    })?;
+    Ok(())
+}
+
+fn step_sync(stmt: &Arc<RefCell<Option<turso_core::Statement>>>) -> napi::Result<u32> {
+    let mut stmt_ref = stmt.borrow_mut();
+    let stmt = stmt_ref
+        .as_mut()
+        .ok_or_else(|| Error::new(Status::GenericFailure, "Statement has been finalized"))?;
+
+    match stmt.step() {
+        Ok(turso_core::StepResult::Row) => Ok(STEP_ROW),
+        Ok(turso_core::StepResult::IO) => Ok(STEP_IO),
+        Ok(turso_core::StepResult::Done) => Ok(STEP_DONE),
+        Ok(turso_core::StepResult::Interrupt) => Err(Error::new(
+            Status::GenericFailure,
+            "Statement was interrupted",
+        )),
+        Ok(turso_core::StepResult::Busy) => {
+            Err(Error::new(Status::GenericFailure, "Database is busy"))
+        }
+        Err(e) => Err(Error::new(
+            Status::GenericFailure,
+            format!("Step failed: {e}"),
+        )),
+    }
+}
+
 #[napi]
 impl Database {
    /// Creates a new database instance.
@@ -51,9 +152,11 @@ impl Database {
    /// # Arguments
    /// * `path` - The path to the database file.
    #[napi(constructor)]
-    pub fn new(path: String) -> Result<Self> {
-        let is_memory = path == ":memory:";
-        let io: Arc<dyn turso_core::IO> = if is_memory {
+    pub fn new(path: String, opts: Option<DatabaseOpts>) -> Result<Self> {
+        if let Some(opts) = opts {
+            init_tracing(opts.tracing);
+        }
+        let io: Arc<dyn turso_core::IO> = if is_memory(&path) {
            Arc::new(turso_core::MemoryIO::new())
        } else {
            Arc::new(turso_core::PlatformIO::new().map_err(|e| {
@@ -61,6 +164,11 @@ impl Database {
            })?)
        };

+        #[cfg(feature = "browser")]
+        if !is_memory(&path) {
+            return Err(Error::new(Status::GenericFailure, "sync constructor is not supported for FS-backed databases in the WASM. Use async connect(...) method instead".to_string()));
+        }
+
        let file = io
            .open_file(&path, turso_core::OpenFlags::Create, false)
            .map_err(|e| Error::new(Status::GenericFailure, format!("Failed to open file: {e}")))?;
@@ -78,7 +186,7 @@ impl Database {
            .connect()
            .map_err(|e| Error::new(Status::GenericFailure, format!("Failed to connect: {e}")))?;

-        Ok(Self::create(Some(db), io, conn, is_memory))
+        Ok(Self::create(Some(db), io, conn, is_memory(&path)))
    }

    pub fn create(
@@ -90,13 +198,23 @@ impl Database {
        Database {
            _db: db,
            io,
-            conn,
+            conn: Some(conn),
            is_memory,
            is_open: Cell::new(true),
            default_safe_integers: Cell::new(false),
        }
    }

+    fn conn(&self) -> Result<Arc<turso_core::Connection>> {
+        let Some(conn) = self.conn.as_ref() else {
+            return Err(napi::Error::new(
+                napi::Status::GenericFailure,
+                "connection is not set",
+            ));
+        };
+        Ok(conn.clone())
+    }
+
    /// Returns whether the database is in memory-only mode.
    #[napi(getter)]
    pub fn memory(&self) -> bool {
@@ -109,7 +227,7 @@ impl Database {
        self.is_open.get()
    }

-    /// Executes a batch of SQL statements.
+    /// Executes a batch of SQL statements on main thread
    ///
    /// # Arguments
    ///
@@ -117,14 +235,23 @@ impl Database {
    ///
    /// # Returns
    #[napi]
-    pub fn batch(&self, sql: String) -> Result<()> {
-        self.conn.prepare_execute_batch(&sql).map_err(|e| {
-            Error::new(
-                Status::GenericFailure,
-                format!("Failed to execute batch: {e}"),
-            )
-        })?;
-        Ok(())
+    pub fn batch_sync(&self, sql: String) -> Result<()> {
+        batch_sync(&self.conn()?, &sql)
+    }
+
+    /// Executes a batch of SQL statements outside of main thread
+    ///
+    /// # Arguments
+    ///
+    /// * `sql` - The SQL statements to execute.
+    ///
+    /// # Returns
+    #[napi]
+    pub fn batch_async(&self, sql: String) -> Result<AsyncTask<DbTask>> {
+        Ok(AsyncTask::new(DbTask::Batch {
+            conn: self.conn()?.clone(),
+            sql,
+        }))
    }

    /// Prepares a statement for execution.
@@ -139,14 +266,15 @@ impl Database {
    #[napi]
    pub fn prepare(&self, sql: String) -> Result<Statement> {
        let stmt = self
-            .conn
+            .conn()?
            .prepare(&sql)
            .map_err(|e| Error::new(Status::GenericFailure, format!("{e}")))?;
        let column_names: Vec<std::ffi::CString> = (0..stmt.num_columns())
            .map(|i| std::ffi::CString::new(stmt.get_column_name(i).to_string()).unwrap())
            .collect();
        Ok(Statement {
-            stmt: RefCell::new(Some(stmt)),
+            #[allow(clippy::arc_with_non_send_sync)]
+            stmt: Arc::new(RefCell::new(Some(stmt))),
            column_names,
            mode: RefCell::new(PresentationMode::Expanded),
            safe_integers: Cell::new(self.default_safe_integers.get()),
@@ -160,7 +288,7 @@ impl Database {
    /// The rowid of the last row inserted.
    #[napi]
    pub fn last_insert_rowid(&self) -> Result<i64> {
-        Ok(self.conn.last_insert_rowid())
+        Ok(self.conn()?.last_insert_rowid())
    }

    /// Returns the number of changes made by the last statement.
@@ -170,7 +298,7 @@ impl Database {
    /// The number of changes made by the last statement.
    #[napi]
    pub fn changes(&self) -> Result<i64> {
-        Ok(self.conn.changes())
+        Ok(self.conn()?.changes())
    }

    /// Returns the total number of changes made by all statements.
@@ -180,7 +308,7 @@ impl Database {
    /// The total number of changes made by all statements.
    #[napi]
    pub fn total_changes(&self) -> Result<i64> {
-        Ok(self.conn.total_changes())
+        Ok(self.conn()?.total_changes())
    }

    /// Closes the database connection.
@@ -189,9 +317,10 @@ impl Database {
    ///
    /// `Ok(())` if the database is closed successfully.
    #[napi]
-    pub fn close(&self) -> Result<()> {
+    pub fn close(&mut self) -> Result<()> {
        self.is_open.set(false);
-        // Database close is handled automatically when dropped
+        let _ = self._db.take().unwrap();
+        let _ = self.conn.take().unwrap();
        Ok(())
    }

@@ -225,7 +354,7 @@ impl Database {
 /// A prepared statement.
 #[napi]
 pub struct Statement {
-    stmt: RefCell<Option<turso_core::Statement>>,
+    stmt: Arc<RefCell<Option<turso_core::Statement>>>,
    column_names: Vec<std::ffi::CString>,
    mode: RefCell<PresentationMode>,
    safe_integers: Cell<bool>,
@@ -344,31 +473,20 @@ impl Statement {
        Ok(())
    }

-    /// Step the statement and return result code:
+    /// Step the statement and return result code (executed on the main thread):
    /// 1 = Row available, 2 = Done, 3 = I/O needed
    #[napi]
-    pub fn step(&self) -> Result<u32> {
-        let mut stmt_ref = self.stmt.borrow_mut();
-        let stmt = stmt_ref
-            .as_mut()
-            .ok_or_else(|| Error::new(Status::GenericFailure, "Statement has been finalized"))?;
+    pub fn step_sync(&self) -> Result<u32> {
+        step_sync(&self.stmt)
+    }

-        match stmt.step() {
-            Ok(turso_core::StepResult::Row) => Ok(STEP_ROW),
-            Ok(turso_core::StepResult::Done) => Ok(STEP_DONE),
-            Ok(turso_core::StepResult::IO) => Ok(STEP_IO),
-            Ok(turso_core::StepResult::Interrupt) => Err(Error::new(
-                Status::GenericFailure,
-                "Statement was interrupted",
-            )),
-            Ok(turso_core::StepResult::Busy) => {
-                Err(Error::new(Status::GenericFailure, "Database is busy"))
-            }
-            Err(e) => Err(Error::new(
-                Status::GenericFailure,
-                format!("Step failed: {e}"),
-            )),
-        }
+    /// Step the statement and return result code (executed on the background thread):
+    /// 1 = Row available, 2 = Done, 3 = I/O needed
+    #[napi]
+    pub fn step_async(&self) -> Result<AsyncTask<DbTask>> {
+        Ok(AsyncTask::new(DbTask::Step {
+            stmt: self.stmt.clone(),
+        }))
    }

    /// Get the current row data according to the presentation mode
@@ -543,8 +661,17 @@ fn to_js_value<'a>(
        turso_core::Value::Float(f) => ToNapiValue::into_unknown(*f, env),
        turso_core::Value::Text(s) => ToNapiValue::into_unknown(s.as_str(), env),
        turso_core::Value::Blob(b) => {
-            let buffer = Buffer::from(b.as_slice());
-            ToNapiValue::into_unknown(buffer, env)
+            #[cfg(not(feature = "browser"))]
+            {
+                let buffer = Buffer::from(b.as_slice());
+                ToNapiValue::into_unknown(buffer, env)
+            }
+            // emnapi do not support Buffer
+            #[cfg(feature = "browser")]
+            {
+                let buffer = Uint8Array::from(b.as_slice());
+                ToNapiValue::into_unknown(buffer, env)
+            }
        }
    }
 }
--- a/bindings/javascript/turso.wasi.cjs
+++ b/bindings/javascript/turso.wasi.cjs
@@ -1,112 +0,0 @@
-/* eslint-disable */
-/* prettier-ignore */
-
-/* auto-generated by NAPI-RS */
-
-const __nodeFs = require('node:fs')
-const __nodePath = require('node:path')
-const { WASI: __nodeWASI } = require('node:wasi')
-const { Worker } = require('node:worker_threads')
-
-const {
-  createOnMessage: __wasmCreateOnMessageForFsProxy,
-  getDefaultContext: __emnapiGetDefaultContext,
-  instantiateNapiModuleSync: __emnapiInstantiateNapiModuleSync,
-} = require('@napi-rs/wasm-runtime')
-
-const __rootDir = __nodePath.parse(process.cwd()).root
-
-const __wasi = new __nodeWASI({
-  version: 'preview1',
-  env: process.env,
-  preopens: {
-    [__rootDir]: __rootDir,
-  }
-})
-
-const __emnapiContext = __emnapiGetDefaultContext()
-
-const __sharedMemory = new WebAssembly.Memory({
-  initial: 4000,
-  maximum: 65536,
-  shared: true,
-})
-
-let __wasmFilePath = __nodePath.join(__dirname, 'turso.wasm32-wasi.wasm')
-const __wasmDebugFilePath = __nodePath.join(__dirname, 'turso.wasm32-wasi.debug.wasm')
-
-if (__nodeFs.existsSync(__wasmDebugFilePath)) {
-  __wasmFilePath = __wasmDebugFilePath
-} else if (!__nodeFs.existsSync(__wasmFilePath)) {
-  try {
-    __wasmFilePath = __nodePath.resolve('@tursodatabase/database-wasm32-wasi')
-  } catch {
-    throw new Error('Cannot find turso.wasm32-wasi.wasm file, and @tursodatabase/database-wasm32-wasi package is not installed.')
-  }
-}
-
-const { instance: __napiInstance, module: __wasiModule, napiModule: __napiModule } = __emnapiInstantiateNapiModuleSync(__nodeFs.readFileSync(__wasmFilePath), {
-  context: __emnapiContext,
-  asyncWorkPoolSize: (function() {
-    const threadsSizeFromEnv = Number(process.env.NAPI_RS_ASYNC_WORK_POOL_SIZE ?? process.env.UV_THREADPOOL_SIZE)
-    // NaN > 0 is false
-    if (threadsSizeFromEnv > 0) {
-      return threadsSizeFromEnv
-    } else {
-      return 4
-    }
-  })(),
-  reuseWorker: true,
-  wasi: __wasi,
-  onCreateWorker() {
-    const worker = new Worker(__nodePath.join(__dirname, 'wasi-worker.mjs'), {
-      env: process.env,
-    })
-    worker.onmessage = ({ data }) => {
-      __wasmCreateOnMessageForFsProxy(__nodeFs)(data)
-    }
-
-    // The main thread of Node.js waits for all the active handles before exiting.
-    // But Rust threads are never waited without `thread::join`.
-    // So here we hack the code of Node.js to prevent the workers from being referenced (active).
-    // According to https://github.com/nodejs/node/blob/19e0d472728c79d418b74bddff588bea70a403d0/lib/internal/worker.js#L415,
-    // a worker is consist of two handles: kPublicPort and kHandle.
-    {
-      const kPublicPort = Object.getOwnPropertySymbols(worker).find(s =>
-        s.toString().includes("kPublicPort")
-      );
-      if (kPublicPort) {
-        worker[kPublicPort].ref = () => {};
-      }
-
-      const kHandle = Object.getOwnPropertySymbols(worker).find(s =>
-        s.toString().includes("kHandle")
-      );
-      if (kHandle) {
-        worker[kHandle].ref = () => {};
-      }
-
-      worker.unref();
-    }
-    return worker
-  },
-  overwriteImports(importObject) {
-    importObject.env = {
-      ...importObject.env,
-      ...importObject.napi,
-      ...importObject.emnapi,
-      memory: __sharedMemory,
-    }
-    return importObject
-  },
-  beforeInit({ instance }) {
-    for (const name of Object.keys(instance.exports)) {
-      if (name.startsWith('__napi_register__')) {
-        instance.exports[name]()
-      }
-    }
-  },
-})
-module.exports = __napiModule.exports
-module.exports.Database = __napiModule.exports.Database
-module.exports.Statement = __napiModule.exports.Statement
--- a/bindings/javascript/wasi-worker-browser.mjs
+++ b/bindings/javascript/wasi-worker-browser.mjs
@@ -1,32 +0,0 @@
-import { instantiateNapiModuleSync, MessageHandler, WASI } from '@napi-rs/wasm-runtime'
-
-const handler = new MessageHandler({
-  onLoad({ wasmModule, wasmMemory }) {
-    const wasi = new WASI({
-      print: function () {
-        // eslint-disable-next-line no-console
-        console.log.apply(console, arguments)
-      },
-      printErr: function() {
-        // eslint-disable-next-line no-console
-        console.error.apply(console, arguments)
-      },
-    })
-    return instantiateNapiModuleSync(wasmModule, {
-      childThread: true,
-      wasi,
-      overwriteImports(importObject) {
-        importObject.env = {
-          ...importObject.env,
-          ...importObject.napi,
-          ...importObject.emnapi,
-          memory: wasmMemory,
-        }
-      },
-    })
-  },
-})
-
-globalThis.onmessage = function (e) {
-  handler.handle(e)
-}
--- a/bindings/javascript/wasi-worker.mjs
+++ b/bindings/javascript/wasi-worker.mjs
@@ -1,63 +0,0 @@
-import fs from "node:fs";
-import { createRequire } from "node:module";
-import { parse } from "node:path";
-import { WASI } from "node:wasi";
-import { parentPort, Worker } from "node:worker_threads";
-
-const require = createRequire(import.meta.url);
-
-const { instantiateNapiModuleSync, MessageHandler, getDefaultContext } = require("@napi-rs/wasm-runtime");
-
-if (parentPort) {
-  parentPort.on("message", (data) => {
-    globalThis.onmessage({ data });
-  });
-}
-
-Object.assign(globalThis, {
-  self: globalThis,
-  require,
-  Worker,
-  importScripts: function (f) {
-    ;(0, eval)(fs.readFileSync(f, "utf8") + "//# sourceURL=" + f);
-  },
-  postMessage: function (msg) {
-    if (parentPort) {
-      parentPort.postMessage(msg);
-    }
-  },
-});
-
-const emnapiContext = getDefaultContext();
-
-const __rootDir = parse(process.cwd()).root;
-
-const handler = new MessageHandler({
-  onLoad({ wasmModule, wasmMemory }) {
-    const wasi = new WASI({
-      version: 'preview1',
-      env: process.env,
-      preopens: {
-        [__rootDir]: __rootDir,
-      },
-    });
-
-    return instantiateNapiModuleSync(wasmModule, {
-      childThread: true,
-      wasi,
-      context: emnapiContext,
-      overwriteImports(importObject) {
-        importObject.env = {
-          ...importObject.env,
-          ...importObject.napi,
-          ...importObject.emnapi,
-          memory: wasmMemory
-        };
-      },
-    });
-  },
-});
-
-globalThis.onmessage = function (e) {
-  handler.handle(e);
-};
--- a/bindings/javascript/yarn.lock
+++ b/bindings/javascript/yarn.lock
--- a/core/lib.rs
+++ b/core/lib.rs
@@ -626,6 +626,38 @@ impl Database {
        Ok(pager)
    }

+    #[cfg(feature = "fs")]
+    pub fn io_for_path(path: &str) -> Result<Arc<dyn IO>> {
+        use crate::util::MEMORY_PATH;
+        let io: Arc<dyn IO> = match path.trim() {
+            MEMORY_PATH => Arc::new(MemoryIO::new()),
+            _ => Arc::new(PlatformIO::new()?),
+        };
+        Ok(io)
+    }
+
+    #[cfg(feature = "fs")]
+    pub fn io_for_vfs<S: AsRef<str> + std::fmt::Display>(vfs: S) -> Result<Arc<dyn IO>> {
+        let vfsmods = ext::add_builtin_vfs_extensions(None)?;
+        let io: Arc<dyn IO> = match vfsmods
+            .iter()
+            .find(|v| v.0 == vfs.as_ref())
+            .map(|v| v.1.clone())
+        {
+            Some(vfs) => vfs,
+            None => match vfs.as_ref() {
+                "memory" => Arc::new(MemoryIO::new()),
+                "syscall" => Arc::new(SyscallIO::new()?),
+                #[cfg(all(target_os = "linux", feature = "io_uring"))]
+                "io_uring" => Arc::new(UringIO::new()?),
+                other => {
+                    return Err(LimboError::InvalidArgument(format!("no such VFS: {other}")));
+                }
+            },
+        };
+        Ok(io)
+    }
+
    /// Open a new database file with optionally specifying a VFS without an existing database
    /// connection and symbol table to register extensions.
    #[cfg(feature = "fs")]
@@ -639,40 +671,13 @@ impl Database {
    where
        S: AsRef<str> + std::fmt::Display,
    {
-        use crate::util::MEMORY_PATH;
-        let vfsmods = ext::add_builtin_vfs_extensions(None)?;
-        match vfs {
-            Some(vfs) => {
-                let io: Arc<dyn IO> = match vfsmods
-                    .iter()
-                    .find(|v| v.0 == vfs.as_ref())
-                    .map(|v| v.1.clone())
-                {
-                    Some(vfs) => vfs,
-                    None => match vfs.as_ref() {
-                        "memory" => Arc::new(MemoryIO::new()),
-                        "syscall" => Arc::new(SyscallIO::new()?),
-                        #[cfg(all(target_os = "linux", feature = "io_uring"))]
-                        "io_uring" => Arc::new(UringIO::new()?),
-                        other => {
-                            return Err(LimboError::InvalidArgument(format!(
-                                "no such VFS: {other}"
-                            )));
-                        }
-                    },
-                };
-                let db = Self::open_file_with_flags(io.clone(), path, flags, opts)?;
-                Ok((io, db))
-            }
-            None => {
-                let io: Arc<dyn IO> = match path.trim() {
-                    MEMORY_PATH => Arc::new(MemoryIO::new()),
-                    _ => Arc::new(PlatformIO::new()?),
-                };
-                let db = Self::open_file_with_flags(io.clone(), path, flags, opts)?;
-                Ok((io, db))
-            }
-        }
+        let io = vfs
+            .map(|vfs| Self::io_for_vfs(vfs))
+            .or_else(|| Some(Self::io_for_path(path)))
+            .transpose()?
+            .unwrap();
+        let db = Self::open_file_with_flags(io.clone(), path, flags, opts)?;
+        Ok((io, db))
    }

    #[inline]
@@ -1304,12 +1309,17 @@ impl Connection {
    }

    #[cfg(feature = "fs")]
-    fn from_uri_attached(uri: &str, db_opts: DatabaseOpts) -> Result<Arc<Database>> {
+    fn from_uri_attached(
+        uri: &str,
+        db_opts: DatabaseOpts,
+        io: Arc<dyn IO>,
+    ) -> Result<Arc<Database>> {
        let mut opts = OpenOptions::parse(uri)?;
        // FIXME: for now, only support read only attach
        opts.mode = OpenMode::ReadOnly;
        let flags = opts.get_flags()?;
-        let (_io, db) = Database::open_new(&opts.path, opts.vfs.as_ref(), flags, db_opts)?;
+        let io = opts.vfs.map(Database::io_for_vfs).unwrap_or(Ok(io))?;
+        let db = Database::open_file_with_flags(io.clone(), &opts.path, flags, db_opts)?;
        if let Some(modeof) = opts.modeof {
            let perms = std::fs::metadata(modeof)?;
            std::fs::set_permissions(&opts.path, perms.permissions())?;
@@ -1852,7 +1862,7 @@ impl Connection {
            .with_indexes(use_indexes)
            .with_views(use_views)
            .with_strict(use_strict);
-        let db = Self::from_uri_attached(path, db_opts)?;
+        let db = Self::from_uri_attached(path, db_opts, self._db.io.clone())?;
        let pager = Rc::new(db.init_pager(None)?);

        self.attached_databases
--- a/core/vdbe/execute.rs
+++ b/core/vdbe/execute.rs
@@ -6994,16 +6994,34 @@ pub fn op_open_ephemeral(
            let conn = program.connection.clone();
            let io = conn.pager.borrow().io.clone();
            let rand_num = io.generate_random_number();
-            let temp_dir = temp_dir();
-            let rand_path =
-                std::path::Path::new(&temp_dir).join(format!("tursodb-ephemeral-{rand_num}"));
-            let Some(rand_path_str) = rand_path.to_str() else {
-                return Err(LimboError::InternalError(
-                    "Failed to convert path to string".to_string(),
-                ));
-            };
-            let file = io.open_file(rand_path_str, OpenFlags::Create, false)?;
-            let db_file = Arc::new(DatabaseFile::new(file));
+            let db_file;
+            let db_file_io: Arc<dyn crate::IO>;
+
+            // we support OPFS in WASM - but it require files to be pre-opened in the browser before use
+            // we can fix this if we will make open_file interface async
+            // but for now for simplicity we use MemoryIO for all intermediate calculations
+            #[cfg(target_family = "wasm")]
+            {
+                use crate::MemoryIO;
+
+                db_file_io = Arc::new(MemoryIO::new());
+                let file = db_file_io.open_file("temp-file", OpenFlags::Create, false)?;
+                db_file = Arc::new(DatabaseFile::new(file));
+            }
+            #[cfg(not(target_family = "wasm"))]
+            {
+                let temp_dir = temp_dir();
+                let rand_path =
+                    std::path::Path::new(&temp_dir).join(format!("tursodb-ephemeral-{rand_num}"));
+                let Some(rand_path_str) = rand_path.to_str() else {
+                    return Err(LimboError::InternalError(
+                        "Failed to convert path to string".to_string(),
+                    ));
+                };
+                let file = io.open_file(rand_path_str, OpenFlags::Create, false)?;
+                db_file = Arc::new(DatabaseFile::new(file));
+                db_file_io = io;
+            }

            let page_size = pager
                .io
@@ -7016,7 +7034,7 @@ pub fn op_open_ephemeral(
            let pager = Rc::new(Pager::new(
                db_file,
                None,
-                io,
+                db_file_io,
                page_cache,
                buffer_pool.clone(),
                Arc::new(AtomicDbState::new(DbState::Uninitialized)),
				`@@ -1 +0,0 @@`
				`export * from '@tursodatabase/database-wasm32-wasi'`