@evolu/web 3.0.0-next.0 → 3.0.0

package/dist/src/Worker.js

@@ -1,7 +1,84 @@
-import { assert, createConsole, createConsoleStoreOutput } from "@evolu/common";
+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;
+});
+import { assert, createConsole, createConsoleStoreOutput, disposable, } from "@evolu/common";
 /** Creates a {@link Worker} from a Web Worker. */
 export const createWorker = (nativeWorker) => wrap(nativeWorker);
-/** Creates an Evolu {@link SharedWorker} from a Web SharedWorker. */
+/**
+ * Installs a one-tab SharedWorker polyfill backed by a Web Worker.
+ *
+ * Use it before constructing a SharedWorker in browsers without native
+ * SharedWorker support.
+ */
+export const installOneTabSharedWorkerPolyfill = () => {
+    if (typeof globalThis.SharedWorker === "function")
+        return;
+    Object.defineProperty(globalThis, "SharedWorker", {
+        configurable: true,
+        writable: true,
+        value: class {
+            port;
+            constructor(scriptURL, options) {
+                this.port = new globalThis.Worker(scriptURL, options);
+            }
+        },
+    });
+};
+/**
+ * Creates a {@link SharedWorker} from a Web SharedWorker.
+ *
+ * Call {@link installOneTabSharedWorkerPolyfill} first to support browsers
+ * without native SharedWorker support.
+ */
 export const createSharedWorker = (nativeSharedWorker) => {
     const port = wrap(nativeSharedWorker.port);
     return {
@@ -21,15 +98,26 @@ export const createSharedWorker = (nativeSharedWorker) => {
  * ```
  */
 export const createMessageChannel = () => {
-    const channel = new globalThis.MessageChannel();
-    const stack = new DisposableStack();
-    return {
-        port1: stack.use(wrap(channel.port1)),
-        port2: stack.use(wrap(channel.port2)),
-        [Symbol.dispose]: () => {
-            stack.dispose();
-        },
-    };
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const channel = new globalThis.MessageChannel();
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        const port1 = disposer.use(wrap(channel.port1));
+        const port2 = disposer.use(wrap(channel.port2));
+        const disposables = disposer.move();
+        return {
+            port1,
+            port2,
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 };
 /**
  * Creates an Evolu {@link MessagePort} from a Web MessagePort.
@@ -37,6 +125,46 @@ export const createMessageChannel = () => {
  * Use this for ports received via postMessage transfer.
  */
 export const createMessagePort = (nativePort) => wrap(nativePort);
+/** Creates an Evolu {@link BroadcastChannel} from a Web BroadcastChannel. */
+export const createBroadcastChannel = (name) => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const nativeBroadcastChannel = new globalThis.BroadcastChannel(name);
+        const disposer = __addDisposableResource(env_2, new DisposableStack(), false);
+        let disposed = false;
+        disposer.defer(() => {
+            disposed = true;
+            nativeBroadcastChannel.onmessage = null;
+            nativeBroadcastChannel.close();
+        });
+        let onMessageHandler = null;
+        return disposable({
+            postMessage: (message) => {
+                nativeBroadcastChannel.postMessage(message);
+            },
+            get onMessage() {
+                return disposed ? null : onMessageHandler;
+            },
+            set onMessage(fn) {
+                if (disposed)
+                    return;
+                onMessageHandler = fn;
+                nativeBroadcastChannel.onmessage = fn
+                    ? (event) => {
+                        fn(event.data);
+                    }
+                    : null;
+            },
+        }, disposer);
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
+};
 /**
  * Creates an Evolu {@link WorkerSelf} from a Web `DedicatedWorkerGlobalScope`
  * (`self` inside a dedicated worker).
@@ -62,6 +190,95 @@ export const createSharedWorkerSelf = (nativeSelf) => {
     };
     return self;
 };
+/**
+ * Creates a one-tab {@link SharedWorkerSelf} polyfill for browsers without
+ * native SharedWorker support.
+ *
+ * Delivers one synthetic `onConnect` port, queues startup messages until
+ * `onMessage` is set, and does not share state across tabs.
+ */
+export const createOneTabSharedWorkerSelfPolyfill = (nativeSelf) => {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const disposer = __addDisposableResource(env_3, new DisposableStack(), false);
+        let onConnectHandler = null;
+        let onMessageHandler = null;
+        const messages = [];
+        let connected = false;
+        disposer.defer(() => {
+            messages.length = 0;
+            onConnectHandler = null;
+            onMessageHandler = null;
+            nativeSelf.onmessage = null;
+            nativeSelf.close();
+        });
+        const disposables = disposer.move();
+        nativeSelf.onmessage = (event) => {
+            if (disposables.disposed)
+                return;
+            const handler = onMessageHandler;
+            if (handler)
+                handler(event.data);
+            else
+                messages.push(event.data);
+        };
+        const flushMessages = () => {
+            for (const message of messages.splice(0)) {
+                const handler = onMessageHandler;
+                if (!handler)
+                    return;
+                handler(message);
+            }
+        };
+        const port = {
+            postMessage: (message, transfer) => {
+                if (disposables.disposed)
+                    return;
+                if (transfer == null)
+                    nativeSelf.postMessage(message);
+                else
+                    nativeSelf.postMessage(message, [...transfer]);
+            },
+            get onMessage() {
+                return disposables.disposed ? null : onMessageHandler;
+            },
+            set onMessage(fn) {
+                if (disposables.disposed)
+                    return;
+                onMessageHandler = fn;
+                if (fn)
+                    flushMessages();
+            },
+            native: nativeSelf,
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+        const connect = () => {
+            if (connected || !onConnectHandler)
+                return;
+            connected = true;
+            onConnectHandler(port);
+        };
+        return {
+            get onConnect() {
+                return onConnectHandler;
+            },
+            set onConnect(fn) {
+                if (disposables.disposed)
+                    return;
+                onConnectHandler = fn;
+                connect();
+            },
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        __disposeResources(env_3);
+    }
+};
 /** Creates deps shared by web worker entry points. */
 export const createWorkerDeps = () => {
     const consoleStoreOutput = createConsoleStoreOutput();
@@ -69,6 +286,8 @@ export const createWorkerDeps = () => {
     return {
         console,
         consoleStoreOutputEntry: consoleStoreOutput.entry,
+        createBroadcastChannel,
+        createMessageChannel,
         createMessagePort,
     };
 };
@@ -99,7 +318,7 @@ const wrap = (native) => {
         native: native,
         [Symbol.dispose]: () => {
             native.onmessage = null;
-            if (native instanceof globalThis.Worker)
+            if ("terminate" in native)
                 native.terminate();
             else
                 native.close();

package/dist/src/index.d.ts

@@ -1,5 +1,6 @@
-export * from "./local-first/index.js";
-export * from "./Sqlite.js";
-export * from "./Task.js";
-export * from "./Worker.js";
+export * from "./local-first/index.ts";
+export { availableParallelism } from "./Platform.ts";
+export * from "./Sqlite.ts";
+export * from "./Task.ts";
+export * from "./Worker.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}

package/dist/src/index.js

@@ -1,4 +1,5 @@
 export * from "./local-first/index.js";
+export { availableParallelism } from "./Platform.js";
 export * from "./Sqlite.js";
 export * from "./Task.js";
 export * from "./Worker.js";

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

@@ -4,13 +4,12 @@ installPolyfills();
 import { createRandomBytes } from "@evolu/common";
 import { startDbWorker } from "@evolu/common/local-first";
 import { createWasmSqliteDriver } from "../Sqlite.js";
-import { createLeaderLock, createRun } from "../Task.js";
+import { createRun } from "../Task.js";
 import { createWorkerDeps, createWorkerSelf } from "../Worker.js";
-// TODO: Disposal.
 const run = createRun({
     ...createWorkerDeps(),
     createSqliteDriver: createWasmSqliteDriver,
-    leaderLock: createLeaderLock(),
+    lockManager: globalThis.navigator.locks,
     randomBytes: createRandomBytes(),
 });
-run(startDbWorker(createWorkerSelf(self)));
+void run(startDbWorker(createWorkerSelf(self)));

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

@@ -1,5 +1,11 @@
-import type { ConsoleDep } from "@evolu/common";
+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>) => EvoluDeps;
+export declare const createEvoluDeps: (deps?: Partial<ConsoleDep> & Partial<SharedWorkerUnsupportedDep>) => EvoluDeps;
 //# sourceMappingURL=Evolu.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Evolu.d.ts","sourceRoot":"","sources":["../../../src/local-first/Evolu.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAGV,SAAS,EAEV,MAAM,2BAA2B,CAAC;AAgBnC,uDAAuD;AACvD,eAAO,MAAM,eAAe,GAAI,OAAM,OAAO,CAAC,UAAU,CAAM,KAAG,SAqBhE,CAAC"}
+{"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,UACpB,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,0BAA0B,CAAC,KAC9D,SAkEF,CAAC"}

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

@@ -1,24 +1,56 @@
+import { exhaustiveCheck } from "@evolu/common";
 import { createEvoluDeps as createCommonEvoluDeps } from "@evolu/common/local-first";
 import { reloadApp } from "../Platform.js";
-import { createMessageChannel, createSharedWorker, createWorker, } from "../Worker.js";
-// // TODO: Redesign.
-// // eslint-disable-next-line evolu/require-pure-annotation
-// export const localAuth = createLocalAuth({
-//   randomBytes: createRandomBytes(),
-//   secureStorage: createWebAuthnStore({ randomBytes: createRandomBytes() }),
-// });
+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 sharedWorker = createSharedWorker(new SharedWorker(new URL("Shared.worker.js", import.meta.url), {
+    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.map

@@ -1 +1 @@
-{"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"}
+{"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,SAAU,cAAc,KAAG,aA4GzD,CAAC"}

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

@@ -1,13 +1,117 @@
+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 } from "@evolu/common";
+import { createWebSocket, ok, waitForAbort } from "@evolu/common";
 import { initSharedWorker } from "@evolu/common/local-first";
 import { createRun } from "../Task.js";
-import { createSharedWorkerSelf, createWorkerDeps } from "../Worker.js";
-// No disposal (`await using`) is needed — a SharedWorker lives forever.
+import { createOneTabSharedWorkerSelfPolyfill, createSharedWorkerSelf, createWorkerDeps, } from "../Worker.js";
 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) {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const _ = __addDisposableResource(env_2, await run.ok(initSharedWorker(createSharedWorkerSelf(self))), true);
+                return await run(waitForAbort);
+            }
+            catch (e_1) {
+                env_2.error = e_1;
+                env_2.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_2);
+                if (result_1)
+                    await result_1;
+            }
+        }
+        const workerSelf = __addDisposableResource(env_1, createOneTabSharedWorkerSelfPolyfill(self), false);
+        await globalThis.navigator.locks.request("evolu-one-tab-sharedworker-polyfill", { ifAvailable: true, mode: "exclusive" }, async (lock) => {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (!lock) {
+                    const message = {
+                        type: "SharedWorkerUnsupported",
+                    };
+                    self.postMessage(message);
+                    return;
+                }
+                const _ = __addDisposableResource(env_3, await run.ok(initSharedWorker(workerSelf)), true);
+                await run(waitForAbort);
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                const result_2 = __disposeResources(env_3);
+                if (result_2)
+                    await result_2;
+            }
+        });
+        return ok();
+    }
+    catch (e_2) {
+        env_1.error = e_2;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 });
-run(initSharedWorker(createSharedWorkerSelf(self)));

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

@@ -1,2 +1,2 @@
-export * from "./Evolu.js";
+export * from "./Evolu.ts";
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/web",
-  "version": "3.0.0-next.0",
+  "version": "3.0.0",
   "description": "Evolu for web",
   "keywords": [
     "evolu",
@@ -8,7 +8,10 @@
   ],
   "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"
   },
@@ -27,22 +30,18 @@
     "src/**",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsc --build tsconfig.build.json",
-    "prepack": "npm run build",
-    "format": "prettier --write \"src/*.{ts,tsx,md}\""
-  },
   "dependencies": {
     "@evolu/sqlite-wasm": "2.2.4",
     "idb-keyval": "^6.2.2"
   },
   "devDependencies": {
-    "@evolu/common": "8.0.0-next.0",
-    "@evolu/typescript-config": "*",
-    "@types/sharedworker": "^0.0.221",
+    "@types/node": "^24.10.9",
+    "@types/sharedworker": "^0.0.229",
     "@types/web-locks-api": "^0.0.5",
-    "typescript": "^5.9.3",
-    "user-agent-data-types": "^0.4.2"
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "user-agent-data-types": "^0.4.2",
+    "@evolu/common": "8.0.0",
+    "@evolu/typescript-config": "0.0.2"
   },
   "peerDependencies": {
     "@evolu/common": "^8.0.0-next.0"
@@ -53,5 +52,9 @@
   "engines": {
     "node": ">=24.0.0"
   },
-  "sideEffects": false
-}
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "format": "prettier --write \"src/*.{ts,tsx,md}\""
+  }
+}

package/src/Platform.ts

@@ -1,4 +1,8 @@
-import type { ReloadApp } from "@evolu/common";
+import { PositiveInt, type ReloadApp } from "@evolu/common";
+
+/** Returns the amount of logical processors available to the browser. */
+export const availableParallelism = (): PositiveInt =>
+  PositiveInt.orThrow(globalThis.navigator.hardwareConcurrency);
 
 export const reloadApp: ReloadApp = (url) => {
   if (typeof document === "undefined") {