@evolu/web 2.4.0 → 3.0.0-next.1

package/dist/src/index.js

@@ -1,4 +1,4 @@
 export * from "./local-first/index.js";
-export * from "./SharedWebWorker.js";
-export * from "./WasmSqliteDriver.js";
-export * from "./WebWorker.js";
+export * from "./Sqlite.js";
+export * from "./Task.js";
+export * from "./Worker.js";

package/dist/src/local-first/Db.worker.js

@@ -1,13 +1,16 @@
-import { createConsole, createRandom, createRandomBytes, createTime, createWebSocket, } from "@evolu/common";
-import { createDbWorkerForPlatform } from "@evolu/common/local-first";
-import { createWasmSqliteDriver } from "../WasmSqliteDriver.js";
-import { wrapWebWorkerSelf } from "../WebWorker.js";
-const dbWorker = createDbWorkerForPlatform({
-    console: createConsole(),
+/// <reference lib="webworker" />
+import { installPolyfills } from "@evolu/common/polyfills";
+installPolyfills();
+import { createRandomBytes } from "@evolu/common";
+import { startDbWorker } from "@evolu/common/local-first";
+import { createWasmSqliteDriver } from "../Sqlite.js";
+import { createRun } from "../Task.js";
+import { createWorkerDeps, createWorkerSelf } from "../Worker.js";
+// TODO: Disposal.
+const run = createRun({
+    ...createWorkerDeps(),
     createSqliteDriver: createWasmSqliteDriver,
-    createWebSocket,
-    random: createRandom(),
+    lockManager: globalThis.navigator.locks,
     randomBytes: createRandomBytes(),
-    time: createTime(),
 });
-wrapWebWorkerSelf(dbWorker);
+run(startDbWorker(createWorkerSelf(self)));

package/dist/src/local-first/Evolu.d.ts

@@ -0,0 +1,11 @@
+import { type ConsoleDep } from "@evolu/common";
+import type { EvoluDeps } from "@evolu/common/local-first";
+export interface SharedWorkerUnsupported {
+    readonly type: "SharedWorkerUnsupported";
+}
+export interface SharedWorkerUnsupportedDep {
+    readonly onSharedWorkerUnsupported: () => void;
+}
+/** Creates Evolu dependencies for the web platform. */
+export declare const createEvoluDeps: (deps?: Partial<ConsoleDep> & Partial<SharedWorkerUnsupportedDep>) => EvoluDeps;
+//# sourceMappingURL=Evolu.d.ts.map

package/dist/src/local-first/Evolu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Evolu.d.ts","sourceRoot":"","sources":["../../../src/local-first/Evolu.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,KAAK,EAIV,SAAS,EAGV,MAAM,2BAA2B,CAAC;AAkBnC,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;CAC1C;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,yBAAyB,EAAE,MAAM,IAAI,CAAC;CAChD;AAED,uDAAuD;AACvD,eAAO,MAAM,eAAe,GAC1B,OAAM,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,0BAA0B,CAAM,KACnE,SAkEF,CAAC"}

package/dist/src/local-first/Evolu.js

@@ -0,0 +1,57 @@
+import { exhaustiveCheck } from "@evolu/common";
+import { createEvoluDeps as createCommonEvoluDeps } from "@evolu/common/local-first";
+import { reloadApp } from "../Platform.js";
+import { createBroadcastChannel, createMessageChannel, createSharedWorker, createWorker, installOneTabSharedWorkerPolyfill, } from "../Worker.js";
+/** Creates Evolu dependencies for the web platform. */
+export const createEvoluDeps = (deps = {}) => {
+    installOneTabSharedWorkerPolyfill();
+    const createDbWorker = () => createWorker(new Worker(new URL("Db.worker.js", import.meta.url), {
+        type: "module",
+    }));
+    const webSharedWorker = createSharedWorker(new SharedWorker(new URL("Shared.worker.js", import.meta.url), {
+        type: "module",
+    }));
+    let onSharedWorkerMessage = null;
+    const sharedWorker = {
+        ...webSharedWorker,
+        port: {
+            ...webSharedWorker.port,
+            get onMessage() {
+                return onSharedWorkerMessage;
+            },
+            set onMessage(fn) {
+                onSharedWorkerMessage = fn;
+                webSharedWorker.port.onMessage = fn
+                    ? (message) => {
+                        switch (message.type) {
+                            case "DbWorkerInit": {
+                                fn(message);
+                                break;
+                            }
+                            case "SharedWorkerUnsupported": {
+                                if (deps.onSharedWorkerUnsupported) {
+                                    deps.onSharedWorkerUnsupported();
+                                }
+                                else {
+                                    globalThis.alert("This browser supports Evolu in one tab only. Close this tab and use the already open tab.");
+                                }
+                                break;
+                            }
+                            default:
+                                exhaustiveCheck(message);
+                        }
+                    }
+                    : null;
+            },
+        },
+    };
+    return createCommonEvoluDeps({
+        ...deps,
+        createDbWorker,
+        createBroadcastChannel,
+        createMessageChannel,
+        lockManager: globalThis.navigator.locks,
+        reloadApp,
+        sharedWorker,
+    });
+};

package/dist/src/local-first/LocalAuth.d.ts

@@ -1,4 +1,3 @@
-import type { SecureStorage, RandomBytesDep, SymmetricCryptoDep } from "@evolu/common";
-/** @experimental */
-export declare const createWebAuthnStore: (deps: RandomBytesDep & SymmetricCryptoDep) => SecureStorage;
+import type { RandomBytesDep, SecureStorage } from "@evolu/common";
+export declare const createWebAuthnStore: (deps: RandomBytesDep) => SecureStorage;
 //# sourceMappingURL=LocalAuth.d.ts.map

package/dist/src/local-first/LocalAuth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LocalAuth.d.ts","sourceRoot":"","sources":["../../../src/local-first/LocalAuth.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAIV,aAAa,EACb,cAAc,EACd,kBAAkB,EACnB,MAAM,eAAe,CAAC;AAGvB,oBAAoB;AACpB,eAAO,MAAM,mBAAmB,GAC9B,MAAM,cAAc,GAAG,kBAAkB,KACxC,aA4GD,CAAC"}
+{"version":3,"file":"LocalAuth.d.ts","sourceRoot":"","sources":["../../../src/local-first/LocalAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EACd,aAAa,EAEd,MAAM,eAAe,CAAC;AAiBvB,eAAO,MAAM,mBAAmB,GAAI,MAAM,cAAc,KAAG,aA4GzD,CAAC"}

package/dist/src/local-first/LocalAuth.js

@@ -1,6 +1,5 @@
-import { set, get, del, keys, clear, createStore } from "idb-keyval";
-import { createSlip21, utf8ToBytes, bytesToUtf8, base64UrlToUint8Array, uint8ArrayToBase64Url, EncryptionKey, Base64Url, } from "@evolu/common";
-/** @experimental */
+import { Base64Url, base64UrlToUint8Array, bytesToUtf8, createSlip21, decryptWithXChaCha20Poly1305, EncryptionKey, encryptWithXChaCha20Poly1305, Entropy24, uint8ArrayToBase64Url, utf8ToBytes, XChaCha20Poly1305Ciphertext, } from "@evolu/common";
+import { clear, createStore, del, get, keys, set } from "idb-keyval";
 export const createWebAuthnStore = (deps) => ({
     setItem: async (key, value, options) => {
         if (options?.accessControl === "none") {
@@ -38,7 +37,7 @@ export const createWebAuthnStore = (deps) => ({
             const credential = await getCredential(deps)(data.credentialId, options?.relyingPartyID, options?.webAuthnUserVerification);
             const credentialSeed = extractSeedFromCredential(credential);
             const encryptionKey = deriveEncryptionKey(credentialSeed);
-            const authResultVal = decryptAuthResult(deps)(data, encryptionKey);
+            const authResultVal = decryptAuthResult(data, encryptionKey);
             if (!authResultVal) {
                 return null;
             }
@@ -81,18 +80,14 @@ export const createWebAuthnStore = (deps) => ({
  * Create default metadata for backwards compatibility with items that don't
  * have stored metadata.
  */
-const createMetadata = (isSecure = true) => {
-    return {
-        backend: "keychain",
-        accessControl: isSecure ? "biometryCurrentSet" : "none",
-        securityLevel: isSecure ? "biometry" : "software",
-        timestamp: Date.now(),
-    };
-};
+const createMetadata = (isSecure = true) => ({
+    backend: "keychain",
+    accessControl: isSecure ? "biometryCurrentSet" : "none",
+    securityLevel: isSecure ? "biometry" : "software",
+    timestamp: Date.now(),
+});
 /** Get storage key for owner ID. (supports namespaces via prefix) */
-const getStore = (prefix = "default") => {
-    return createStore(prefix, "evolu-auth");
-};
+const getStore = (prefix = "default") => createStore(prefix, "evolu-auth");
 const createCredential = (deps) => async (username, seed, relyingPartyID, relyingPartyName, userVerification, authenticatorAttachment) => {
     const options = createCredentialCreationOptions(deps)(username, seed, relyingPartyID, relyingPartyName, userVerification, authenticatorAttachment);
     const credential = (await navigator.credentials.create(options));
@@ -116,78 +111,72 @@ const extractSeedFromCredential = (credential) => {
     }
     return new Uint8Array(response.userHandle);
 };
-const createCredentialCreationOptions = (deps) => (username, seed, relyingPartyID, relyingPartyName, userVerification, authenticatorAttachment) => {
-    return {
-        publicKey: {
-            challenge: generateSeed(deps)(),
-            rp: {
-                id: relyingPartyID ?? document.location.hostname,
-                name: relyingPartyName ?? "Evolu",
-            },
-            user: {
-                id: seed,
-                name: username,
-                displayName: username,
-            },
-            pubKeyCredParams: [
-                { type: "public-key", alg: -8 }, // Ed25519
-                { type: "public-key", alg: -7 }, // ES256
-                { type: "public-key", alg: -257 }, // RS256
-            ],
-            attestation: "none",
-            authenticatorSelection: {
-                // - "platform": Uses the platform's built-in authenticator.
-                // - "cross-platform": Uses a device specific authenticator (yubikey, fido2, etc.)
-                authenticatorAttachment: authenticatorAttachment ?? "platform",
-                // - "discouraged": Only User Presence is needed.
-                // - "preferred": User Verification is preferred but not required. Falls back to User Presence.
-                // - "required": User Verification MUST occur (biometrics/PIN). Clients may silently downgrade to User Presence only.
-                userVerification: userVerification ?? "required",
-                // - "discouraged": Server-side credential is preferable, but will accept client-side discoverable credential.
-                // - "preferred": Relying Party strongly prefers client-side discoverable credential but will accept server-side credential.
-                // - "required": Client-side discoverable credential MUST be created, error if it can't be created.
-                residentKey: "required",
-                // Included for backwards compatibility. Deprecated in favor of residentKey (true = "required")
-                requireResidentKey: true,
-            },
+const createCredentialCreationOptions = (deps) => (username, seed, relyingPartyID, relyingPartyName, userVerification, authenticatorAttachment) => ({
+    publicKey: {
+        challenge: generateSeed(deps)(),
+        rp: {
+            id: relyingPartyID ?? document.location.hostname,
+            name: relyingPartyName ?? "Evolu",
         },
-    };
-};
-const createCredentialRequestOptions = (deps) => (credentialId, relyingPartyID, userVerification) => {
-    return {
-        publicKey: {
-            challenge: generateSeed(deps)(),
-            rpId: relyingPartyID ?? document.location.hostname,
-            userVerification: userVerification ?? "preferred",
-            allowCredentials: [
-                {
-                    type: "public-key",
-                    id: base64UrlToUint8Array(Base64Url.orThrow(credentialId)),
-                },
-            ],
+        user: {
+            id: seed,
+            name: username,
+            displayName: username,
         },
-    };
-};
+        pubKeyCredParams: [
+            { type: "public-key", alg: -8 }, // Ed25519
+            { type: "public-key", alg: -7 }, // ES256
+            { type: "public-key", alg: -257 }, // RS256
+        ],
+        attestation: "none",
+        authenticatorSelection: {
+            // - "platform": Uses the platform's built-in authenticator.
+            // - "cross-platform": Uses a device specific authenticator (yubikey, fido2, etc.)
+            authenticatorAttachment: authenticatorAttachment ?? "platform",
+            // - "discouraged": Only User Presence is needed.
+            // - "preferred": User Verification is preferred but not required. Falls back to User Presence.
+            // - "required": User Verification MUST occur (biometrics/PIN). Clients may silently downgrade to User Presence only.
+            userVerification: userVerification ?? "required",
+            // - "discouraged": Server-side credential is preferable, but will accept client-side discoverable credential.
+            // - "preferred": Relying Party strongly prefers client-side discoverable credential but will accept server-side credential.
+            // - "required": Client-side discoverable credential MUST be created, error if it can't be created.
+            residentKey: "required",
+            // Included for backwards compatibility. Deprecated in favor of residentKey (true = "required")
+            requireResidentKey: true,
+        },
+    },
+});
+const createCredentialRequestOptions = (deps) => (credentialId, relyingPartyID, userVerification) => ({
+    publicKey: {
+        challenge: generateSeed(deps)(),
+        rpId: relyingPartyID ?? document.location.hostname,
+        userVerification: userVerification ?? "preferred",
+        allowCredentials: [
+            {
+                type: "public-key",
+                id: base64UrlToUint8Array(Base64Url.orThrow(credentialId)),
+            },
+        ],
+    },
+});
 const deriveEncryptionKey = (seed) => {
     const seed32 = seed.length === 32 ? seed : seed.slice(0, 32);
     return EncryptionKey.orThrow(createSlip21(seed32, ["evolu", "auth"]));
 };
 const encryptAuthResult = (deps) => (authResult, encryptionKey) => {
     const plaintext = utf8ToBytes(JSON.stringify(authResult));
-    const { nonce, ciphertext } = deps.symmetricCrypto.encrypt(plaintext, encryptionKey);
+    const [ciphertext, nonce] = encryptWithXChaCha20Poly1305(deps)(plaintext, encryptionKey);
     return {
         nonce: uint8ArrayToBase64Url(nonce),
         ciphertext: uint8ArrayToBase64Url(ciphertext),
     };
 };
-const decryptAuthResult = (deps) => (encryptedData, encryptionKey) => {
+const decryptAuthResult = (encryptedData, encryptionKey) => {
     const nonce = base64UrlToUint8Array(encryptedData.nonce);
     const ciphertext = base64UrlToUint8Array(encryptedData.ciphertext);
-    const result = deps.symmetricCrypto.decrypt(ciphertext, encryptionKey, nonce);
+    const result = decryptWithXChaCha20Poly1305(XChaCha20Poly1305Ciphertext.orThrow(ciphertext), Entropy24.orThrow(nonce), encryptionKey);
     if (!result.ok)
         return null;
     return bytesToUtf8(result.value);
 };
-const generateSeed = (deps) => () => {
-    return deps.randomBytes.create(32);
-};
+const generateSeed = (deps) => () => deps.randomBytes.create(32);

package/dist/src/local-first/Shared.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Shared.worker.d.ts.map

package/dist/src/local-first/Shared.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Shared.worker.d.ts","sourceRoot":"","sources":["../../../src/local-first/Shared.worker.ts"],"names":[],"mappings":""}

package/dist/src/local-first/Shared.worker.js

@@ -0,0 +1,94 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+/// <reference lib="webworker" />
+import { installPolyfills } from "@evolu/common/polyfills";
+installPolyfills();
+import { createWebSocket, ok } from "@evolu/common";
+import { initSharedWorker } from "@evolu/common/local-first";
+import { createRun } from "../Task.js";
+import { createOneTabSharedWorkerSelfPolyfill, createSharedWorkerSelf, createWorkerDeps, } from "../Worker.js";
+// No disposal (`await using`) is needed — a SharedWorker lives forever.
+const run = createRun({
+    ...createWorkerDeps(),
+    createWebSocket,
+    lockManager: globalThis.navigator.locks,
+});
+void run(async (run) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        if ("onconnect" in self) {
+            void run(initSharedWorker(createSharedWorkerSelf(self)));
+            return ok();
+        }
+        const workerSelf = __addDisposableResource(env_1, createOneTabSharedWorkerSelfPolyfill(self), false);
+        await globalThis.navigator.locks.request("evolu-one-tab-sharedworker-polyfill", { ifAvailable: true, mode: "exclusive" }, async (lock) => {
+            if (!lock) {
+                const message = {
+                    type: "SharedWorkerUnsupported",
+                };
+                self.postMessage(message);
+                return;
+            }
+            void run(initSharedWorker(workerSelf));
+            await Promise.withResolvers().promise;
+        });
+        return ok();
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+});

package/dist/src/local-first/index.d.ts

@@ -1,4 +1,2 @@
-import { EvoluDeps } from "@evolu/common/local-first";
-export declare const localAuth: import("@evolu/common").LocalAuth;
-export declare const evoluWebDeps: EvoluDeps;
+export * from "./Evolu.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/local-first/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/local-first/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,SAAS,EACV,MAAM,2BAA2B,CAAC;AAiBnC,eAAO,MAAM,SAAS,mCAGpB,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,SAM1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/local-first/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/src/local-first/index.js

@@ -1,20 +1 @@
-import { createConsole, createLocalAuth, createRandomBytes, createSymmetricCrypto, createTime, } from "@evolu/common";
-import { createSharedWebWorker } from "../SharedWebWorker.js";
-import { createWebAuthnStore } from "./LocalAuth.js";
-import { reloadApp } from "./Platform.js";
-const randomBytes = createRandomBytes();
-const symmetricCrypto = createSymmetricCrypto({ randomBytes });
-const createDbWorker = (name) => createSharedWebWorker(name, () => new Worker(new URL("Db.worker.js", import.meta.url), {
-    type: "module",
-}));
-export const localAuth = createLocalAuth({
-    randomBytes,
-    secureStorage: createWebAuthnStore({ randomBytes, symmetricCrypto }),
-});
-export const evoluWebDeps = {
-    console: createConsole(),
-    createDbWorker,
-    randomBytes: createRandomBytes(),
-    reloadApp,
-    time: createTime(),
-};
+export * from "./Evolu.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/web",
-  "version": "2.4.0",
+  "version": "3.0.0-next.1",
   "description": "Evolu for web",
   "keywords": [
     "evolu",
@@ -8,13 +8,16 @@
   ],
   "author": "Daniel Steigerwald <daniel@steigerwald.cz>",
   "license": "MIT",
-  "repository": "evoluhq/evolu",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/evoluhq/evolu.git"
+  },
   "bugs": {
     "url": "https://github.com/evoluhq/evolu/issues"
   },
   "homepage": "https://evolu.dev",
   "type": "module",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/src/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
@@ -23,7 +26,7 @@
     }
   },
   "files": [
-    "dist/**",
+    "dist/src/**",
     "src/**",
     "README.md"
   ],
@@ -32,29 +35,26 @@
     "idb-keyval": "^6.2.2"
   },
   "devDependencies": {
+    "@types/node": "^24.10.9",
+    "@types/sharedworker": "^0.0.221",
     "@types/web-locks-api": "^0.0.5",
-    "typescript": "^5.9.2",
+    "typescript": "^6",
     "user-agent-data-types": "^0.4.2",
-    "vitest": "^4.0.4",
-    "@evolu/common": "7.4.0",
-    "@evolu/tsconfig": "0.0.2"
+    "@evolu/common": "8.0.0-next.5",
+    "@evolu/typescript-config": "0.0.2"
   },
   "peerDependencies": {
-    "@evolu/common": "^7.4.0"
+    "@evolu/common": "^8.0.0-next.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=24.0.0"
   },
-  "sideEffects": [],
+  "sideEffects": false,
   "scripts": {
-    "dev": "tsc --watch",
-    "build": "rimraf dist && tsc",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "clean": "rimraf .turbo node_modules dist",
+    "build": "tsc --build tsconfig.build.json",
     "format": "prettier --write \"src/*.{ts,tsx,md}\""
   }
 }

package/src/Platform.ts

@@ -0,0 +1,9 @@
+import type { ReloadApp } from "@evolu/common";
+
+export const reloadApp: ReloadApp = (url) => {
+  if (typeof document === "undefined") {
+    return;
+  }
+
+  location.replace(url ?? "/");
+};

package/src/Sqlite.ts

@@ -0,0 +1,138 @@
+import type { CreateSqliteDriver, SqliteRow } from "@evolu/common";
+import { bytesToHex, createPreparedStatementsCache, ok } from "@evolu/common";
+import sqlite3InitModule, {
+  type Database,
+  type PreparedStatement,
+  type SAHPoolUtil,
+} from "@evolu/sqlite-wasm";
+
+// @ts-expect-error Missing types.
+globalThis.sqlite3ApiConfig = {
+  warn: (arg: unknown) => {
+    // Ignore irrelevant warning.
+    // https://github.com/sqlite/sqlite-wasm/issues/62
+    if (
+      typeof arg === "string" &&
+      arg.startsWith("Ignoring inability to install OPFS sqlite3_vfs")
+    )
+      return;
+    // eslint-disable-next-line no-console
+    console.warn(arg);
+  },
+};
+
+// Init ASAP.
+const sqlite3Promise = sqlite3InitModule();
+
+const fileName = "evolu1.db";
+
+export const createWasmSqliteDriver: CreateSqliteDriver =
+  (name, options) => async () => {
+    const sqlite3 = await sqlite3Promise;
+
+    using disposer = new DisposableStack();
+    const useDatabase = (database: Database): Database =>
+      disposer.adopt(database, (database) => {
+        database.close();
+      });
+
+    let deleteDatabaseFile = false;
+    const createOpfsSAHPoolVfs = async (
+      options: Parameters<typeof sqlite3.installOpfsSAHPoolVfs>[0],
+    ): Promise<SAHPoolUtil> => {
+      const pool = await sqlite3.installOpfsSAHPoolVfs(options);
+      if (pool.isPaused()) await pool.unpauseVfs();
+      disposer.defer(() => {
+        if (deleteDatabaseFile) pool.unlink(`/${fileName}`);
+        pool.pauseVfs();
+      });
+      return pool;
+    };
+
+    let db: Database;
+
+    switch (options?.mode) {
+      case "memory":
+        db = useDatabase(new sqlite3.oo1.DB(":memory:"));
+        break;
+
+      case "encrypted": {
+        // MultipleCiphers encryption requires its VFS wrapper for OPFS SAH-pool.
+        // @ts-expect-error Missing types (update @evolu/sqlite-wasm types)
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        sqlite3.capi.sqlite3mc_vfs_create("opfs", 1);
+        const pool = await createOpfsSAHPoolVfs({
+          directory: `.${name}`,
+        });
+        db = useDatabase(
+          new pool.OpfsSAHPoolDb(
+            // SQLite normalizes this URI filename to SAH-pool path "/evolu1.db".
+            `file:${fileName}?vfs=multipleciphers-opfs-sahpool`,
+          ),
+        );
+        db.exec(`
+          PRAGMA cipher = 'sqlcipher';
+          PRAGMA key = "x'${bytesToHex(options.encryptionKey)}'";
+        `);
+        break;
+      }
+
+      default: {
+        const pool = await createOpfsSAHPoolVfs({ name });
+        db = useDatabase(new pool.OpfsSAHPoolDb(`file:${fileName}`));
+      }
+    }
+
+    const cache = disposer.use(
+      createPreparedStatementsCache<PreparedStatement>(
+        (sql) => db.prepare(sql),
+        (statement) => {
+          statement.finalize();
+        },
+      ),
+    );
+
+    const disposables = disposer.move();
+
+    return ok({
+      exec: (query) => {
+        const prepared = cache.get(query);
+
+        if (prepared) {
+          if (query.parameters.length > 0) prepared.bind(query.parameters);
+
+          const rows = [];
+          while (prepared.step()) {
+            rows.push(prepared.get({}));
+          }
+          prepared.reset();
+
+          return {
+            rows: rows as ReadonlyArray<SqliteRow>,
+            changes: db.changes(),
+          };
+        }
+
+        const rows = db.exec(query.sql, {
+          returnValue: "resultRows",
+          rowMode: "object",
+          bind: query.parameters,
+        }) as ReadonlyArray<SqliteRow>;
+
+        const changes = db.changes();
+
+        return { rows, changes };
+      },
+
+      export: () => sqlite3.capi.sqlite3_js_db_export(db),
+
+      deleteDatabase: () => {
+        deleteDatabaseFile = true;
+        disposables.dispose();
+      },
+
+      [Symbol.dispose]: () => {
+        disposables.dispose();
+      },
+    });
+  };