data-of-loathing 3.0.3 → 3.1.0

package/README.md

@@ -24,8 +24,19 @@ export default defineConfig({
 });
 ```
 
-The plugin does three things:
+The plugin does two things by default:
 
-- Configures Vite's dependency optimiser and worker format for SQLocal's WASM worker
+- Configures Vite's dependency optimiser to prevent pre-bundling of the SQLite WASM
 - Polyfills `Buffer` (required by the underlying SQLite driver)
-- Sets `Cross-Origin-Embedder-Policy: credentialless` and `Cross-Origin-Opener-Policy: same-origin` on the dev server so SharedArrayBuffer is available without blocking cross-origin images — for production you must set these headers at the hosting layer (e.g. Netlify `_headers`, Vercel `headers` config, nginx)
+
+#### OPFS strategy
+
+If you use the `"opfs"` strategy, SQLite requires `SharedArrayBuffer` and `Atomics`, which in turn require cross-origin isolation headers. Pass `{ coi: true }` to enable them on the dev server:
+
+```ts
+export default defineConfig({
+  plugins: [dol({ coi: true })],
+});
+```
+
+This sets `Cross-Origin-Embedder-Policy: credentialless` and `Cross-Origin-Opener-Policy: same-origin` on the dev server. For production you must set these headers at the hosting layer (e.g. Netlify `_headers`, Vercel `headers` config, nginx). The `credentialless` value is used rather than `require-corp` so cross-origin images are not blocked.

package/dist/SqliteWorkerDialect.d.ts

@@ -0,0 +1,12 @@
+import { type DatabaseIntrospector, type Dialect, type DialectAdapter, type Driver, type Kysely, type QueryCompiler } from "kysely";
+export declare class SqliteWorkerDialect implements Dialect {
+    #private;
+    constructor(worker: Worker);
+    loadMemory(buffer: ArrayBuffer): Promise<void>;
+    loadOpfs(filename: string): Promise<void>;
+    loadRanged(url: string): Promise<void>;
+    createDriver(): Driver;
+    createQueryCompiler(): QueryCompiler;
+    createAdapter(): DialectAdapter;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+}

package/dist/SqliteWorkerDialect.js

@@ -0,0 +1,72 @@
+import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, } from "kysely";
+export class SqliteWorkerDialect {
+    #worker;
+    #pending = new Map();
+    #nextId = 0;
+    constructor(worker) {
+        this.#worker = worker;
+        this.#worker.onmessage = (event) => {
+            const pending = this.#pending.get(event.data.id);
+            if (!pending)
+                return;
+            this.#pending.delete(event.data.id);
+            if (event.data.type === "error") {
+                pending.reject(new Error(event.data.error));
+            }
+            else if (event.data.type === "exec") {
+                pending.resolve(event.data.rows);
+            }
+            else {
+                pending.resolve(undefined);
+            }
+        };
+    }
+    #send(message, transfer) {
+        const id = String(++this.#nextId);
+        const promise = new Promise((resolve, reject) => {
+            this.#pending.set(id, { resolve: (v) => resolve(v), reject });
+        });
+        this.#worker.postMessage({ ...message, id }, transfer ?? []);
+        return promise;
+    }
+    loadMemory(buffer) {
+        return this.#send({ type: "load", buffer }, [buffer]);
+    }
+    loadOpfs(filename) {
+        return this.#send({ type: "load", filename });
+    }
+    loadRanged(url) {
+        return this.#send({ type: "load", url });
+    }
+    createDriver() {
+        const dialect = this;
+        const connection = {
+            executeQuery(query) {
+                return dialect
+                    .#send({ type: "exec", sql: query.sql, bind: [...query.parameters] })
+                    .then((rows) => ({ rows }));
+            },
+            async *streamQuery() {
+                throw new Error("Streaming not supported");
+            },
+        };
+        return {
+            async init() { },
+            async acquireConnection() { return connection; },
+            async beginTransaction() { },
+            async commitTransaction() { },
+            async rollbackTransaction() { },
+            async releaseConnection() { },
+            async destroy() { dialect.#worker.terminate(); },
+        };
+    }
+    createQueryCompiler() {
+        return new SqliteQueryCompiler();
+    }
+    createAdapter() {
+        return new SqliteAdapter();
+    }
+    createIntrospector(db) {
+        return new SqliteIntrospector(db);
+    }
+}

package/dist/browser.d.ts

@@ -1,11 +1,18 @@
 import { BaseClient } from "./BaseClient.js";
 export type Strategy = {
-    strategy?: "url";
+    strategy?: "memory";
     url?: string;
     force?: boolean;
+} | {
+    strategy: "opfs";
+    url?: string;
+    force?: boolean;
+} | {
+    strategy: "ranged";
+    url?: string;
 };
 export declare class Client extends BaseClient<Strategy> {
-    private _db?;
+    #private;
     constructor(strategy?: Strategy);
     protected getStoredEtag(_key: string): Promise<string | null>;
     protected storeEtag(_key: string, etag: string): Promise<void>;

package/dist/browser.js

@@ -1,9 +1,33 @@
 import { SqlMikroORM, SqliteDriver } from "@mikro-orm/sql";
-import { SQLocalKysely } from "sqlocal/kysely";
 import { entities } from "./schema.js";
+import { SqliteWorkerDialect } from "./SqliteWorkerDialect.js";
 import { BaseClient, DEFAULT_URL, ETAG_KEY } from "./BaseClient.js";
+async function getOpfsEtag() {
+    try {
+        const root = await navigator.storage.getDirectory();
+        const handle = await root.getFileHandle(".dol-etag");
+        return (await handle.getFile()).text();
+    }
+    catch {
+        return null;
+    }
+}
+async function setOpfsEtag(etag) {
+    const root = await navigator.storage.getDirectory();
+    const handle = await root.getFileHandle(".dol-etag", { create: true });
+    const writable = await handle.createWritable();
+    await writable.write(etag);
+    await writable.close();
+}
+async function writeToOpfs(filename, buffer) {
+    const root = await navigator.storage.getDirectory();
+    const handle = await root.getFileHandle(filename, { create: true });
+    const writable = await handle.createWritable();
+    await writable.write(buffer);
+    await writable.close();
+}
 export class Client extends BaseClient {
-    _db;
+    #dialect;
     constructor(strategy = {}) {
         super(strategy);
     }
@@ -15,14 +39,45 @@ export class Client extends BaseClient {
     }
     async load() {
         await this._orm?.close();
+        this.#dialect?.createDriver().destroy();
+        const strategy = this._strategy;
         const url = this._strategy.url ?? DEFAULT_URL;
-        if (!this._db) {
-            this._db = new SQLocalKysely("dol.sqlite");
+        switch (strategy.strategy) {
+            case "ranged": {
+                this.#dialect = new SqliteWorkerDialect(new Worker(new URL("./workers/ranged.js", import.meta.url), { type: "module" }));
+                await this.#dialect.loadRanged(url);
+                break;
+            }
+            case "opfs": {
+                this.#dialect = new SqliteWorkerDialect(new Worker(new URL("./workers/opfs.js", import.meta.url), { type: "module" }));
+                const { force = false } = strategy;
+                const remoteEtag = (await fetch(url, { method: "HEAD" })).headers.get("etag");
+                const storedEtag = force ? null : await getOpfsEtag();
+                if (force || storedEtag !== remoteEtag) {
+                    const buffer = await this.fetchDb(url);
+                    await writeToOpfs("dol.sqlite", buffer);
+                    if (remoteEtag)
+                        await setOpfsEtag(remoteEtag);
+                }
+                await this.#dialect.loadOpfs("/dol.sqlite");
+                break;
+            }
+            case "memory":
+            default: {
+                this.#dialect = new SqliteWorkerDialect(new Worker(new URL("./workers/memory.js", import.meta.url), { type: "module" }));
+                const { force = false } = strategy;
+                const response = await fetch(url, {
+                    cache: force ? "reload" : "default",
+                });
+                if (!response.ok)
+                    throw new Error(`Failed to fetch database: ${response.status}`);
+                const buffer = await response.arrayBuffer();
+                await this.#dialect.loadMemory(buffer);
+            }
         }
-        await this.syncIfNeeded(url, ETAG_KEY, (data) => this._db.overwriteDatabaseFile(data), this._strategy.force);
         this._orm = await SqlMikroORM.init({
             driver: SqliteDriver,
-            driverOptions: this._db.dialect,
+            driverOptions: this.#dialect,
             dbName: "dol.sqlite",
             entities,
             allowGlobalContext: true,

package/dist/node.js

@@ -19,10 +19,10 @@ export class Client extends BaseClient {
         const strategy = this._strategy;
         switch (strategy.strategy) {
             case "local":
-                return this._strategy.path;
+                return strategy.path;
             default:
             case "url": {
-                const { url = DEFAULT_URL, force = false } = this._strategy.strategy === "url" ? this._strategy : {};
+                const { url = DEFAULT_URL, force = false } = strategy;
                 const cacheDir = join(homedir(), ".cache", "data-of-loathing");
                 const dbPath = join(cacheDir, "dol.sqlite");
                 const etagPath = join(cacheDir, "etag");

package/dist/vite.d.ts

@@ -0,0 +1,4 @@
+import type { PluginOption } from "vite";
+export default function dol({ coi }?: {
+    coi?: boolean;
+}): PluginOption[];

package/dist/vite.js

@@ -0,0 +1,23 @@
+import { nodePolyfills } from "vite-plugin-node-polyfills";
+export default function dol({ coi = false } = {}) {
+    const plugin = {
+        name: "data-of-loathing",
+        config() {
+            return {
+                optimizeDeps: {
+                    exclude: ["@sqlite.org/sqlite-wasm"],
+                },
+            };
+        },
+    };
+    if (coi) {
+        plugin.configureServer = (server) => {
+            server.middlewares.use((_, res, next) => {
+                res.setHeader("Cross-Origin-Embedder-Policy", "credentialless");
+                res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
+                next();
+            });
+        };
+    }
+    return [nodePolyfills({ include: ["buffer"] }), plugin];
+}

package/dist/workers/memory.js

@@ -0,0 +1,28 @@
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+let db;
+let sqlite3;
+self.onmessage = async (event) => {
+    const { type, id } = event.data;
+    try {
+        sqlite3 ??= await sqlite3InitModule();
+        switch (type) {
+            case "load": {
+                const { buffer } = event.data;
+                const p = sqlite3.wasm.allocFromTypedArray(new Uint8Array(buffer));
+                db = new sqlite3.oo1.DB();
+                sqlite3.capi.sqlite3_deserialize(db.pointer, "main", p, buffer.byteLength, buffer.byteLength, sqlite3.capi.SQLITE_DESERIALIZE_FREEONCLOSE | sqlite3.capi.SQLITE_DESERIALIZE_READONLY);
+                self.postMessage({ id, type: "loaded" });
+                break;
+            }
+            case "exec": {
+                const rows = [];
+                db.exec({ sql: event.data.sql, bind: event.data.bind, rowMode: "object", resultRows: rows });
+                self.postMessage({ id, type: "exec", rows });
+                break;
+            }
+        }
+    }
+    catch (e) {
+        self.postMessage({ id, type: "error", error: String(e) });
+    }
+};

package/dist/workers/opfs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workers/opfs.js

@@ -0,0 +1,25 @@
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+let db;
+let sqlite3;
+self.onmessage = async (event) => {
+    const { type, id } = event.data;
+    try {
+        sqlite3 ??= await sqlite3InitModule();
+        switch (type) {
+            case "load": {
+                db = new sqlite3.oo1.OpfsDb(event.data.filename);
+                self.postMessage({ id, type: "loaded" });
+                break;
+            }
+            case "exec": {
+                const rows = [];
+                db.exec({ sql: event.data.sql, bind: event.data.bind, rowMode: "object", resultRows: rows });
+                self.postMessage({ id, type: "exec", rows });
+                break;
+            }
+        }
+    }
+    catch (e) {
+        self.postMessage({ id, type: "error", error: String(e) });
+    }
+};

package/dist/workers/ranged.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workers/ranged.js

@@ -0,0 +1,203 @@
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+let db;
+let sqlite3;
+const fileUrls = new Map();
+const fileSizes = new Map();
+const readCache = new Map();
+let vfsInstalled = false;
+function syncFetchRange(url, start, end) {
+    try {
+        const xhr = new XMLHttpRequest();
+        xhr.open("GET", url, false);
+        xhr.responseType = "arraybuffer";
+        xhr.setRequestHeader("Range", `bytes=${start}-${end}`);
+        xhr.send();
+        if (xhr.status !== 200 && xhr.status !== 206)
+            return null;
+        const data = new Uint8Array(xhr.response);
+        let totalSize = null;
+        const contentRange = xhr.getResponseHeader("Content-Range");
+        if (contentRange) {
+            const match = /\/(\d+)$/.exec(contentRange);
+            if (match)
+                totalSize = parseInt(match[1], 10);
+        }
+        if (totalSize === null) {
+            const cl = xhr.getResponseHeader("Content-Length");
+            if (cl)
+                totalSize = parseInt(cl, 10);
+        }
+        return { data, totalSize };
+    }
+    catch {
+        return null;
+    }
+}
+function structSizeof(capi) {
+    const tmp = new capi.sqlite3_file();
+    const size = tmp.structInfo.sizeof;
+    tmp.dispose();
+    return size;
+}
+function installRangedVfs(s3) {
+    if (vfsInstalled)
+        return;
+    vfsInstalled = true;
+    const { capi, wasm } = s3;
+    const ioMethods = new capi.sqlite3_io_methods();
+    ioMethods.iVersion = 1;
+    const vfsStruct = new capi.sqlite3_vfs();
+    vfsStruct.$iVersion = 1;
+    vfsStruct.$szOsFile = structSizeof(capi);
+    vfsStruct.$mxPathname = 2048;
+    s3.vfs.installVfs({
+        io: {
+            struct: ioMethods,
+            methods: {
+                xClose(pFile) {
+                    fileUrls.delete(pFile);
+                    fileSizes.delete(pFile);
+                    readCache.delete(pFile);
+                    return capi.SQLITE_OK;
+                },
+                xRead(pFile, pBuf, iAmt, iOfst) {
+                    const url = fileUrls.get(pFile);
+                    if (!url)
+                        return capi.SQLITE_IOERR_READ;
+                    // iOfst is BigInt at runtime in WASM_BIGINT builds despite the number type
+                    const offset = Number(iOfst);
+                    const cacheKey = `${offset}:${iAmt}`;
+                    const cache = readCache.get(pFile);
+                    const cached = cache?.get(cacheKey);
+                    if (cached) {
+                        wasm.heap8u().set(cached, pBuf);
+                        return capi.SQLITE_OK;
+                    }
+                    const result = syncFetchRange(url, offset, offset + iAmt - 1);
+                    if (!result)
+                        return capi.SQLITE_IOERR_READ;
+                    cache?.set(cacheKey, result.data);
+                    const heap = wasm.heap8u();
+                    const toCopy = Math.min(result.data.length, iAmt);
+                    heap.set(result.data.subarray(0, toCopy), pBuf);
+                    if (toCopy < iAmt) {
+                        heap.fill(0, pBuf + toCopy, pBuf + iAmt);
+                        return capi.SQLITE_IOERR_SHORT_READ;
+                    }
+                    return capi.SQLITE_OK;
+                },
+                xWrite() { return capi.SQLITE_READONLY; },
+                xTruncate() { return capi.SQLITE_READONLY; },
+                xSync() { return capi.SQLITE_OK; },
+                xFileSize(pFile, pSize) {
+                    const url = fileUrls.get(pFile);
+                    if (!url)
+                        return capi.SQLITE_IOERR;
+                    let size = fileSizes.get(pFile);
+                    if (size === undefined) {
+                        const result = syncFetchRange(url, 0, 0);
+                        size = result?.totalSize ?? 0;
+                        fileSizes.set(pFile, size);
+                    }
+                    // Write i64 as two i32s (little-endian); poke("i64") requires BigInt in WASM_BIGINT mode
+                    wasm.poke(pSize, size >>> 0, "i32");
+                    wasm.poke(pSize + 4, Math.floor(size / 0x100000000), "i32");
+                    return capi.SQLITE_OK;
+                },
+                xLock() { return capi.SQLITE_OK; },
+                xUnlock() { return capi.SQLITE_OK; },
+                xCheckReservedLock(_pFile, pResOut) {
+                    wasm.poke(pResOut, 0, "i32");
+                    return capi.SQLITE_OK;
+                },
+                xFileControl() { return capi.SQLITE_NOTFOUND; },
+                xSectorSize() { return 512; },
+                xDeviceCharacteristics() { return capi.SQLITE_IOCAP_IMMUTABLE; },
+            },
+        },
+        vfs: {
+            struct: vfsStruct,
+            methods: {
+                xOpen(_pVfs, zName, pFile, _flags, pOutFlags) {
+                    const url = zName ? (wasm.cstrToJs(zName) ?? "") : "";
+                    const fileObj = new capi.sqlite3_file(pFile);
+                    fileObj.$pMethods = ioMethods.pointer;
+                    fileUrls.set(pFile, url);
+                    const cache = new Map();
+                    readCache.set(pFile, cache);
+                    // Pre-fetch first 64KB to warm cache with header + early B-tree pages
+                    const prefetch = syncFetchRange(url, 0, 65535);
+                    if (prefetch) {
+                        if (prefetch.totalSize != null)
+                            fileSizes.set(pFile, prefetch.totalSize);
+                        // Detect page size from SQLite header bytes 16-17 (big-endian); value of 1 means 65536
+                        const rawPgSize = prefetch.data.length >= 18
+                            ? ((prefetch.data[16] << 8) | prefetch.data[17])
+                            : 0;
+                        const pageSize = rawPgSize === 1 ? 65536 : (rawPgSize || 4096);
+                        for (let offset = 0; offset + pageSize <= prefetch.data.length; offset += pageSize) {
+                            cache.set(`${offset}:${pageSize}`, prefetch.data.slice(offset, offset + pageSize));
+                        }
+                    }
+                    if (pOutFlags)
+                        wasm.poke(pOutFlags, capi.SQLITE_OPEN_READONLY, "i32");
+                    return capi.SQLITE_OK;
+                },
+                xDelete() { return 1034; /* SQLITE_IOERR_DELETE */ },
+                xAccess(_pVfs, _zName, _flags, pResOut) {
+                    wasm.poke(pResOut, 1, "i32");
+                    return capi.SQLITE_OK;
+                },
+                xFullPathname(_pVfs, zName, nOut, zOut) {
+                    const name = wasm.cstrToJs(zName) ?? "";
+                    const bytes = new TextEncoder().encode(name + "\0");
+                    if (bytes.length > nOut)
+                        return capi.SQLITE_CANTOPEN;
+                    wasm.heap8u().set(bytes, zOut);
+                    return capi.SQLITE_OK;
+                },
+                xRandomness(_pVfs, nByte, zOut) {
+                    const buf = new Uint8Array(nByte);
+                    crypto.getRandomValues(buf);
+                    wasm.heap8u().set(buf, zOut);
+                    return nByte;
+                },
+                xSleep() { return capi.SQLITE_OK; },
+                xCurrentTime(_pVfs, pTimeOut) {
+                    wasm.poke(pTimeOut, Date.now() / 86400000 + 2440587.5, "f64");
+                    return capi.SQLITE_OK;
+                },
+                xGetLastError(_pVfs, nBuf, zBuf) {
+                    if (nBuf > 0)
+                        wasm.poke(zBuf, 0, "i8");
+                    return 0;
+                },
+            },
+            name: "ranged",
+            asDefault: false,
+        },
+    });
+}
+self.onmessage = async (event) => {
+    const { type, id } = event.data;
+    try {
+        sqlite3 ??= await sqlite3InitModule();
+        switch (type) {
+            case "load": {
+                installRangedVfs(sqlite3);
+                db = new sqlite3.oo1.DB(event.data.url, "r", "ranged");
+                self.postMessage({ id, type: "loaded" });
+                break;
+            }
+            case "exec": {
+                const rows = [];
+                db.exec({ sql: event.data.sql, bind: event.data.bind, rowMode: "object", resultRows: rows });
+                self.postMessage({ id, type: "exec", rows });
+                break;
+            }
+        }
+    }
+    catch (e) {
+        self.postMessage({ id, type: "error", error: String(e) });
+    }
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "data-of-loathing",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "type": "module",
   "packageManager": "yarn@4.6.0",
   "repository": {
-    "url": "https://github.com/loathers/data-of-loathing"
+    "url": "git+https://github.com/loathers/data-of-loathing.git"
   },
   "exports": {
     ".": {
@@ -25,7 +25,9 @@
   ],
   "typesVersions": {
     "*": {
-      "vite": ["./dist/vite.d.ts"]
+      "vite": [
+        "./dist/vite.d.ts"
+      ]
     }
   },
   "scripts": {
@@ -33,24 +35,20 @@
   },
   "dependencies": {
     "@mikro-orm/core": "^7.0.14",
-    "@mikro-orm/sql": "^7.0.14"
+    "@mikro-orm/sql": "^7.0.14",
+    "@sqlite.org/sqlite-wasm": "~3.51.2-build9"
   },
   "devDependencies": {
     "@types/node": "^25.0.2",
-    "sqlocal": "^0.18.0",
     "typescript": "^5.9.3",
     "vite": "^6.0.0",
     "vite-plugin-node-polyfills": "^0.26.0"
   },
   "peerDependencies": {
-    "sqlocal": "^0.18.0",
     "vite": ">=5.0.0",
     "vite-plugin-node-polyfills": "^0.26.0"
   },
   "peerDependenciesMeta": {
-    "sqlocal": {
-      "optional": true
-    },
     "vite": {
       "optional": true
     },

package/dist/browser-client.d.ts

@@ -1,17 +0,0 @@
-import { type EntityManager } from "@mikro-orm/core";
-export type Strategy = {
-    strategy?: "cache";
-    url?: string;
-} | {
-    strategy: "remote";
-    url?: string;
-};
-export declare class Client {
-    private _orm?;
-    private readonly _strategy;
-    constructor(strategy?: Strategy);
-    get em(): EntityManager;
-    load(): Promise<void>;
-    private _db?;
-}
-export declare function createClient(strategy?: Strategy): Client;

package/dist/browser-client.js

@@ -1,58 +0,0 @@
-import { SqlMikroORM, SqliteDriver } from "@mikro-orm/sql";
-import { HttpVFSDialect } from "./http-vfs-dialect.js";
-import { entities } from "data-of-loathing-schema";
-const DEFAULT_URL = "https://data.loathers.net/dol.sqlite";
-const ETAG_KEY = "dol-etag";
-export class Client {
-    _orm;
-    _strategy;
-    constructor(strategy = {}) {
-        this._strategy = strategy;
-    }
-    get em() {
-        if (!this._orm)
-            throw new Error("Call await client.load() before querying");
-        return this._orm.em;
-    }
-    async load() {
-        await this._orm?.close();
-        const url = this._strategy.url ?? DEFAULT_URL;
-        if (this._strategy.strategy === "remote") {
-            this._orm = await SqlMikroORM.init({
-                driver: SqliteDriver,
-                driverOptions: new HttpVFSDialect(url),
-                dbName: url,
-                entities,
-                allowGlobalContext: true,
-            });
-            return;
-        }
-        const { SQLocalKysely } = await import("sqlocal/kysely");
-        if (!this._db) {
-            this._db = new SQLocalKysely("dol.sqlite");
-        }
-        const storedEtag = localStorage.getItem(ETAG_KEY);
-        const head = await fetch(url, { method: "HEAD" });
-        const remoteEtag = head.headers.get("etag");
-        if (!storedEtag || storedEtag !== remoteEtag) {
-            const response = await fetch(url);
-            if (!response.ok)
-                throw new Error(`Failed to fetch database: ${response.status}`);
-            await this._db.overwriteDatabaseFile(await response.arrayBuffer());
-            if (remoteEtag)
-                localStorage.setItem(ETAG_KEY, remoteEtag);
-        }
-        this._orm = await SqlMikroORM.init({
-            driver: SqliteDriver,
-            driverOptions: this._db.dialect,
-            dbName: "dol.sqlite",
-            entities,
-            allowGlobalContext: true,
-        });
-    }
-    // sqlocal instance kept across load() calls to preserve OPFS connection
-    _db;
-}
-export function createClient(strategy = {}) {
-    return new Client(strategy);
-}

package/dist/browser-strategies.d.ts

@@ -1,9 +0,0 @@
-export declare const DEFAULT_URL = "https://data.loathers.net/data-of-loathing.sqlite";
-export type BrowserStrategy = {
-    strategy?: "cache";
-    url?: string;
-} | {
-    strategy: "remote";
-    url?: string;
-};
-export declare function resolveDbPath(opts: BrowserStrategy): Promise<string>;