@moyodb/sdk 0.0.0-alpha.1

package/dist/engine/moyodb_engine_bg.wasm.d.ts

@@ -0,0 +1,52 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_wasmengine_free: (a: number, b: number) => void;
+export const cleanupInactiveEntries: (a: number, b: number) => any;
+export const dbDirectorySize: (a: number, b: number) => any;
+export const deleteDB: (a: number, b: number) => any;
+export const prepareRebuildTarget: (a: number, b: number) => any;
+export const swapActiveGeneration: (a: number, b: number, c: number, d: number) => any;
+export const wasmengine_apply_batch: (a: number, b: bigint, c: number, d: number, e: any) => [number, number, number];
+export const wasmengine_apply_batch_packed: (a: number, b: bigint, c: number, d: number, e: any) => [number, number, number];
+export const wasmengine_begin_tx: (a: number, b: number, c: number) => [bigint, number, number];
+export const wasmengine_changes_since: (a: number, b: bigint, c: any) => [number, number, number];
+export const wasmengine_clear_store: (a: number, b: bigint, c: number, d: number) => [number, number];
+export const wasmengine_close: (a: number) => [number, number];
+export const wasmengine_commit_tx: (a: number, b: bigint) => [bigint, number, number];
+export const wasmengine_create_store: (a: number, b: bigint, c: number, d: number, e: any) => [number, number];
+export const wasmengine_delete: (a: number, b: bigint, c: number, d: number, e: number, f: number) => [number, number, number];
+export const wasmengine_delete_many: (a: number, b: bigint, c: number, d: number, e: any) => [number, number, number];
+export const wasmengine_delete_many_packed: (a: number, b: bigint, c: number, d: number, e: any) => [number, number, number];
+export const wasmengine_drop_store: (a: number, b: bigint, c: number, d: number) => [number, number];
+export const wasmengine_export_snapshot: (a: number) => [number, number, number];
+export const wasmengine_get: (a: number, b: bigint, c: number, d: number, e: number, f: number) => [number, number, number];
+export const wasmengine_get_many: (a: number, b: bigint, c: number, d: number, e: any) => [number, number, number];
+export const wasmengine_get_many_packed: (a: number, b: bigint, c: number, d: number, e: any) => [number, number, number];
+export const wasmengine_get_schema_version: (a: number) => [bigint, number, number];
+export const wasmengine_has: (a: number, b: bigint, c: number, d: number, e: number, f: number) => [number, number, number];
+export const wasmengine_import_snapshot: (a: number, b: number, c: number) => [bigint, number, number];
+export const wasmengine_list_store_configs: (a: number) => [number, number, number];
+export const wasmengine_list_stores: (a: number) => [number, number, number];
+export const wasmengine_new: () => number;
+export const wasmengine_open: (a: number, b: number, c: number, d: any) => any;
+export const wasmengine_openGeneration: (a: number, b: number, c: number, d: number, e: number, f: any) => any;
+export const wasmengine_put: (a: number, b: bigint, c: number, d: number, e: number, f: number, g: number, h: number, i: any) => [number, number];
+export const wasmengine_put_many: (a: number, b: bigint, c: number, d: number, e: any, f: any) => [number, number, number];
+export const wasmengine_put_many_packed: (a: number, b: bigint, c: number, d: number, e: any, f: any) => [number, number, number];
+export const wasmengine_reset: (a: number) => [bigint, number, number];
+export const wasmengine_rollback_tx: (a: number, b: bigint) => [number, number];
+export const wasmengine_scan: (a: number, b: bigint, c: number, d: number, e: any) => [number, number, number];
+export const wasmengine_set_failpoint: (a: number, b: any) => [number, number];
+export const wasmengine_set_schema_version: (a: number, b: bigint, c: bigint) => [number, number];
+export const wasmengine_stats: (a: number) => [number, number, number];
+export const wasm_bindgen__convert__closures_____invoke__h0b808fc55658bd50: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h694ddb4a279886ac: (a: number, b: number, c: any, d: any) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_destroy_closure: (a: number, b: number) => void;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/dist/engine/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "moyodb-engine",
+  "type": "module",
+  "description": "Experimental Rust/WASM transactional key-value storage engine for browser apps.",
+  "version": "0.1.0",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/moyodb/moyodb"
+  },
+  "files": [
+    "moyodb_engine_bg.wasm",
+    "moyodb_engine.js",
+    "moyodb_engine.d.ts"
+  ],
+  "main": "moyodb_engine.js",
+  "types": "moyodb_engine.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

package/dist/engine/snippets/moyodb-engine-cff0a0e2441a7a8f/js/opfs_shim.js

@@ -0,0 +1,402 @@
+const DB_ROOT_DIR = 'stackdb';
+const FILE_NAMES = ['manifest.bin', 'main.bin', 'wal.bin'];
+const CONTROL_FILE_NAME = 'root-manifest.bin';
+const CONTROL_SLOT_SIZE = 4096;
+const CONTROL_VERSION = 1;
+const CONTROL_CHECKSUM_OFFSET = 24;
+const CONTROL_NAME_OFFSET = 32;
+const CONTROL_MAGIC = new Uint8Array([66, 68, 66, 82, 79, 79, 84, 49]);
+const OPFS_WRITE_CHUNK_SIZE = 256 * 1024;
+const TEXT_ENCODER = new TextEncoder();
+const TEXT_DECODER = new TextDecoder();
+let rootDir = null;
+let nextSessionId = 1;
+const sessions = new Map();
+async function getRootDir() {
+    if (!navigator?.storage?.getDirectory) {
+        throw new Error('navigator.storage.getDirectory is unavailable');
+    }
+    if (!rootDir) {
+        rootDir = await navigator.storage.getDirectory();
+    }
+    return rootDir;
+}
+async function getOrCreateStackdbRoot() {
+    const root = await getRootDir();
+    return await root.getDirectoryHandle(DB_ROOT_DIR, { create: true });
+}
+async function lookupDirectoryHandle(parent, name) {
+    try {
+        return await parent.getDirectoryHandle(name, { create: false });
+    } catch (_err) {
+        return null;
+    }
+}
+async function lookupFileHandle(parent, name) {
+    try {
+        return await parent.getFileHandle(name, { create: false });
+    } catch (_err) {
+        return null;
+    }
+}
+function sessionPath(encodedDbName, generationName = null) {
+    return generationName ? `${encodedDbName}/${generationName}` : encodedDbName;
+}
+function slotBytesView(bytes) {
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function writeU64(view, offset, value) {
+    view.setBigUint64(offset, BigInt(value), true);
+}
+function readU64(view, offset) {
+    return Number(view.getBigUint64(offset, true));
+}
+function fnv1a32(bytes, zeroOffset = -1, zeroLength = 0) {
+    let hash = 0x811c9dc5;
+    const zeroEnd = zeroOffset >= 0 ? zeroOffset + zeroLength : -1;
+    for (let index = 0; index < bytes.length; index += 1) {
+        const value = zeroOffset >= 0 && index >= zeroOffset && index < zeroEnd ? 0 : (bytes[index] ?? 0);
+        hash ^= value;
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash >>> 0;
+}
+function isGenerationNameValid(name) {
+    return typeof name === 'string' && /^gen-[a-z0-9]+-[a-z0-9]+$/i.test(name);
+}
+function encodeControlSlot(generationCounter, activeGeneration) {
+    if (!isGenerationNameValid(activeGeneration)) {
+        throw new Error(`invalid generation name ${activeGeneration}`);
+    }
+    const nameBytes = TEXT_ENCODER.encode(activeGeneration);
+    if (CONTROL_NAME_OFFSET + nameBytes.length > CONTROL_SLOT_SIZE) {
+        throw new Error(`generation name too long: ${nameBytes.length}`);
+    }
+    const slot = new Uint8Array(CONTROL_SLOT_SIZE);
+    const view = slotBytesView(slot);
+    slot.set(CONTROL_MAGIC, 0);
+    view.setUint32(8, CONTROL_VERSION, true);
+    writeU64(view, 12, generationCounter);
+    view.setUint16(20, nameBytes.length, true);
+    view.setUint16(22, 0, true);
+    view.setUint32(CONTROL_CHECKSUM_OFFSET, 0, true);
+    view.setUint32(28, 0, true);
+    slot.set(nameBytes, CONTROL_NAME_OFFSET);
+    const checksum = fnv1a32(slot, CONTROL_CHECKSUM_OFFSET, 4);
+    view.setUint32(CONTROL_CHECKSUM_OFFSET, checksum, true);
+    return slot;
+}
+function decodeControlSlot(slotIndex, bytes) {
+    if (bytes.length < CONTROL_SLOT_SIZE) {
+        return null;
+    }
+    for (let index = 0; index < CONTROL_MAGIC.length; index += 1) {
+        if (bytes[index] !== CONTROL_MAGIC[index]) {
+            return null;
+        }
+    }
+    const view = slotBytesView(bytes);
+    const version = view.getUint32(8, true);
+    if (version !== CONTROL_VERSION) {
+        throw new Error(`unsupported control file version ${version}`);
+    }
+    const expectedChecksum = fnv1a32(bytes, CONTROL_CHECKSUM_OFFSET, 4);
+    const storedChecksum = view.getUint32(CONTROL_CHECKSUM_OFFSET, true);
+    if (expectedChecksum !== storedChecksum) {
+        return null;
+    }
+    const nameLength = view.getUint16(20, true);
+    const nameEnd = CONTROL_NAME_OFFSET + nameLength;
+    if (nameEnd > CONTROL_SLOT_SIZE) {
+        throw new Error(`control slot name length out of bounds: ${nameLength}`);
+    }
+    const activeGeneration = TEXT_DECODER.decode(bytes.subarray(CONTROL_NAME_OFFSET, nameEnd));
+    if (!isGenerationNameValid(activeGeneration)) {
+        throw new Error(`invalid generation in control slot: ${activeGeneration}`);
+    }
+    return {
+        slotIndex,
+        generationCounter: readU64(view, 12),
+        activeGeneration
+    };
+}
+function readControlStateFromAccessHandle(accessHandle) {
+    const buffer = new Uint8Array(CONTROL_SLOT_SIZE * 2);
+    const size = Number(accessHandle.getSize());
+    if (size <= 0) {
+        return null;
+    }
+    const readLength = Math.min(buffer.length, size);
+    accessHandle.read(buffer.subarray(0, readLength), { at: 0 });
+    const slot0 = decodeControlSlot(0, buffer.subarray(0, CONTROL_SLOT_SIZE));
+    const slot1 = decodeControlSlot(1, buffer.subarray(CONTROL_SLOT_SIZE, CONTROL_SLOT_SIZE * 2));
+    if (slot0 && slot1) {
+        return slot0.generationCounter >= slot1.generationCounter ? slot0 : slot1;
+    }
+    return slot0 ?? slot1 ?? null;
+}
+async function readControlState(dbRoot) {
+    const fileHandle = await lookupFileHandle(dbRoot, CONTROL_FILE_NAME);
+    if (!fileHandle) {
+        return null;
+    }
+    const accessHandle = await fileHandle.createSyncAccessHandle();
+    try {
+        return readControlStateFromAccessHandle(accessHandle);
+    } finally {
+        accessHandle.close();
+    }
+}
+async function writeControlState(dbRoot, activeGeneration) {
+    const fileHandle = await dbRoot.getFileHandle(CONTROL_FILE_NAME, { create: true });
+    const accessHandle = await fileHandle.createSyncAccessHandle();
+    try {
+        const current = readControlStateFromAccessHandle(accessHandle);
+        const nextSlot = current ? (current.slotIndex === 0 ? 1 : 0) : 0;
+        const nextGenerationCounter = (current?.generationCounter ?? 0) + 1;
+        const encoded = encodeControlSlot(nextGenerationCounter, activeGeneration);
+        accessHandle.write(encoded, { at: nextSlot * CONTROL_SLOT_SIZE });
+        accessHandle.flush();
+    } finally {
+        accessHandle.close();
+    }
+}
+function createGenerationName() {
+    const timePart = Date.now().toString(36);
+    const randomBytes = new Uint8Array(4);
+    crypto.getRandomValues(randomBytes);
+    const randomPart = Array.from(randomBytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+    return `gen-${timePart}-${randomPart}`;
+}
+async function getDbRoot(encodedDbName, createIfMissing) {
+    const stackdb = await getOrCreateStackdbRoot();
+    let dbRoot = await lookupDirectoryHandle(stackdb, encodedDbName);
+    if (!dbRoot) {
+        if (!createIfMissing) {
+            throw new Error(`database ${encodedDbName} does not exist`);
+        }
+        dbRoot = await stackdb.getDirectoryHandle(encodedDbName, { create: true });
+    }
+    return dbRoot;
+}
+async function resolveActiveDataDir(dbRoot) {
+    const control = await readControlState(dbRoot);
+    if (!control) {
+        return {
+            dirHandle: dbRoot,
+            generationName: null,
+            path: dbRoot.name
+        };
+    }
+    const activeDir = await lookupDirectoryHandle(dbRoot, control.activeGeneration);
+    if (!activeDir) {
+        throw new Error(`active generation ${control.activeGeneration} is missing`);
+    }
+    return {
+        dirHandle: activeDir,
+        generationName: control.activeGeneration,
+        path: `${dbRoot.name}/${control.activeGeneration}`
+    };
+}
+function closeSession(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+        return;
+    }
+    for (const handle of session.handles.values()) {
+        try {
+            handle.close();
+        } catch (_err) {}
+    }
+    sessions.delete(sessionId);
+}
+function closeSessionsForDb(encodedDbName) {
+    const prefix = `${encodedDbName}/`;
+    for (const [sessionId, session] of Array.from(sessions.entries())) {
+        if (session.path === encodedDbName || session.path.startsWith(prefix)) {
+            closeSession(sessionId);
+        }
+    }
+}
+async function openSessionForDir(dbPath, dirHandle) {
+    const handles = new Map();
+    try {
+        for (let fileKind = 0; fileKind < FILE_NAMES.length; fileKind += 1) {
+            const fileName = FILE_NAMES[fileKind];
+            const fileHandle = await dirHandle.getFileHandle(fileName, { create: true });
+            if (typeof fileHandle.createSyncAccessHandle !== 'function') {
+                throw new Error('createSyncAccessHandle is unavailable');
+            }
+            const accessHandle = await fileHandle.createSyncAccessHandle();
+            handles.set(fileKind, accessHandle);
+        }
+    } catch (error) {
+        for (const handle of handles.values()) {
+            try {
+                handle.close();
+            } catch (_err) {}
+        }
+        throw error;
+    }
+    const sessionId = nextSessionId;
+    nextSessionId += 1;
+    sessions.set(sessionId, {
+        path: dbPath,
+        handles
+    });
+    return { sessionId };
+}
+function getSession(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+        throw new Error(`no OPFS session ${sessionId}`);
+    }
+    return session;
+}
+function getAccessHandle(sessionId, fileKind) {
+    const session = getSession(sessionId);
+    const handle = session.handles.get(fileKind);
+    if (!handle) {
+        throw new Error(`no OPFS access handle for session ${sessionId} file kind ${fileKind}`);
+    }
+    return handle;
+}
+function lookupOpenFileSize(path) {
+    for (const session of sessions.values()) {
+        for (let fileKind = 0; fileKind < FILE_NAMES.length; fileKind += 1) {
+            if (`${session.path}/${FILE_NAMES[fileKind]}` === path) {
+                return Number(session.handles.get(fileKind)?.getSize() ?? 0);
+            }
+        }
+    }
+    return null;
+}
+async function sumDirectorySize(dirHandle, pathPrefix) {
+    let total = 0;
+    for await (const [name, handle] of dirHandle.entries()) {
+        const entryPath = pathPrefix ? `${pathPrefix}/${name}` : name;
+        if (handle.kind === 'directory') {
+            total += await sumDirectorySize(handle, entryPath);
+            continue;
+        }
+        const openSize = lookupOpenFileSize(entryPath);
+        if (openSize !== null) {
+            total += openSize;
+            continue;
+        }
+        const file = await handle.getFile();
+        total += file.size;
+    }
+    return total;
+}
+export async function opfsOpenActiveDb(encodedDbName, createIfMissing = true) {
+    const dbRoot = await getDbRoot(encodedDbName, createIfMissing);
+    const active = await resolveActiveDataDir(dbRoot);
+    return await openSessionForDir(active.path, active.dirHandle);
+}
+export async function opfsOpenGenerationDb(encodedDbName, generationName, createIfMissing = true) {
+    if (!isGenerationNameValid(generationName)) {
+        throw new Error(`invalid generation name ${generationName}`);
+    }
+    const dbRoot = await getDbRoot(encodedDbName, createIfMissing);
+    const generationDir = await dbRoot.getDirectoryHandle(generationName, { create: createIfMissing });
+    return await openSessionForDir(sessionPath(encodedDbName, generationName), generationDir);
+}
+export function opfsReadAt(sessionId, fileKind, offset, len) {
+    const handle = getAccessHandle(sessionId, fileKind);
+    const buffer = new Uint8Array(len);
+    handle.read(buffer, { at: Number(offset) });
+    return buffer;
+}
+export function opfsWriteAt(sessionId, fileKind, offset, bytes) {
+    const handle = getAccessHandle(sessionId, fileKind);
+    const startOffset = Number(offset);
+    let writtenTotal = 0;
+    while (writtenTotal < bytes.length) {
+        const chunk = bytes.subarray(writtenTotal, writtenTotal + OPFS_WRITE_CHUNK_SIZE);
+        const rawWritten = handle.write(chunk, { at: startOffset + writtenTotal });
+        const written = Number(rawWritten);
+        if (!Number.isSafeInteger(written) || written < 0 || written > chunk.length) {
+            throw new Error(`opfs write failed: invalid byte count ${String(rawWritten)}`);
+        }
+        if (written === 0 && chunk.length > 0) {
+            throw new Error('opfs write failed: wrote 0 bytes');
+        }
+        writtenTotal += written;
+    }
+    return writtenTotal;
+}
+export function opfsFlush(sessionId, fileKind) {
+    const handle = getAccessHandle(sessionId, fileKind);
+    handle.flush();
+}
+export function opfsLen(sessionId, fileKind) {
+    const handle = getAccessHandle(sessionId, fileKind);
+    return BigInt(handle.getSize());
+}
+export function opfsTruncate(sessionId, fileKind, size) {
+    const handle = getAccessHandle(sessionId, fileKind);
+    handle.truncate(Number(size));
+}
+export function opfsCloseSession(sessionId) {
+    closeSession(sessionId);
+}
+export async function opfsPrepareRebuildTarget(encodedDbName) {
+    const dbRoot = await getDbRoot(encodedDbName, true);
+    let generationName = createGenerationName();
+    while (await lookupDirectoryHandle(dbRoot, generationName)) {
+        generationName = createGenerationName();
+    }
+    await dbRoot.getDirectoryHandle(generationName, { create: true });
+    return { generationName };
+}
+export async function opfsSwapActiveGeneration(encodedDbName, generationName) {
+    if (!isGenerationNameValid(generationName)) {
+        throw new Error(`invalid generation name ${generationName}`);
+    }
+    const dbRoot = await getDbRoot(encodedDbName, false);
+    const generationDir = await lookupDirectoryHandle(dbRoot, generationName);
+    if (!generationDir) {
+        throw new Error(`generation ${generationName} does not exist`);
+    }
+    await writeControlState(dbRoot, generationName);
+}
+export async function opfsCleanupInactiveEntries(encodedDbName) {
+    const dbRoot = await lookupDirectoryHandle(await getOrCreateStackdbRoot(), encodedDbName);
+    if (!dbRoot) {
+        return;
+    }
+    const control = await readControlState(dbRoot);
+    const activeGeneration = control?.activeGeneration ?? null;
+    for await (const [name, handle] of dbRoot.entries()) {
+        if (name === CONTROL_FILE_NAME) {
+            continue;
+        }
+        if (handle.kind === 'directory') {
+            if (activeGeneration && name === activeGeneration) {
+                continue;
+            }
+            if (name.startsWith('gen-')) {
+                await dbRoot.removeEntry(name, { recursive: true });
+            }
+            continue;
+        }
+        if (activeGeneration && FILE_NAMES.includes(name)) {
+            await dbRoot.removeEntry(name);
+        }
+    }
+}
+export async function opfsDbDirectorySize(encodedDbName) {
+    const dbRoot = await lookupDirectoryHandle(await getOrCreateStackdbRoot(), encodedDbName);
+    if (!dbRoot) {
+        return 0;
+    }
+    return await sumDirectorySize(dbRoot, encodedDbName);
+}
+export async function opfsRemoveDb(encodedDbName) {
+    closeSessionsForDb(encodedDbName);
+    const stackdb = await getOrCreateStackdbRoot();
+    try {
+        await stackdb.removeEntry(encodedDbName, { recursive: true });
+    } catch (_err) {}
+}

package/dist/errors.d.ts

@@ -0,0 +1,77 @@
+export declare class MoyoDbError extends Error {
+    constructor(name: string, message: string);
+}
+export declare class UnsupportedPlatformError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class DatabaseBusyError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class CorruptionError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class StoreExistsError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class StoreNotFoundError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class IndexNotFoundError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class ConstraintError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class UniqueIndexConstraintError extends ConstraintError {
+    constructor(message: string);
+}
+export declare class WriteTransactionAlreadyOpenError extends MoyoDbError {
+    constructor(message?: string);
+}
+export declare class ReadonlyTransactionError extends MoyoDbError {
+    constructor(message?: string);
+}
+export declare class TransactionClosedError extends MoyoDbError {
+    constructor(message?: string);
+}
+export declare class DatabaseClosedError extends MoyoDbError {
+    constructor(message?: string);
+}
+export declare class ValueTooLargeError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class KeyTooLargeError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class StoreNameTooLongError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class ReservedStoreNameError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class InvalidRangeError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class StorageError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class SerializationError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class InjectedFailureError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class ChangeFeedCompactedError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class InternalError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class InvalidOpenOptionsError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare class VersionError extends MoyoDbError {
+    constructor(message: string);
+}
+export declare function normalizeError(error: unknown): Error;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAY,SAAQ,KAAK;gBACtB,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAK5C;AACD,qBAAa,wBAAyB,SAAQ,WAAW;gBACzC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,iBAAkB,SAAQ,WAAW;gBAClC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,eAAgB,SAAQ,WAAW;gBAChC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,gBAAiB,SAAQ,WAAW;gBACjC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,kBAAmB,SAAQ,WAAW;gBACnC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,kBAAmB,SAAQ,WAAW;gBACnC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,eAAgB,SAAQ,WAAW;gBAChC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,0BAA2B,SAAQ,eAAe;gBAC/C,OAAO,EAAE,MAAM;CAI9B;AACD,qBAAa,gCAAiC,SAAQ,WAAW;gBACjD,OAAO,SAAmC;CAGzD;AACD,qBAAa,wBAAyB,SAAQ,WAAW;gBACzC,OAAO,SAAuD;CAG7E;AACD,qBAAa,sBAAuB,SAAQ,WAAW;gBACvC,OAAO,SAAkC;CAGxD;AACD,qBAAa,mBAAoB,SAAQ,WAAW;gBACpC,OAAO,SAA8B;CAGpD;AACD,qBAAa,kBAAmB,SAAQ,WAAW;gBACnC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,gBAAiB,SAAQ,WAAW;gBACjC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,qBAAsB,SAAQ,WAAW;gBACtC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,sBAAuB,SAAQ,WAAW;gBACvC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,iBAAkB,SAAQ,WAAW;gBAClC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,YAAa,SAAQ,WAAW;gBAC7B,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,kBAAmB,SAAQ,WAAW;gBACnC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,oBAAqB,SAAQ,WAAW;gBACrC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,wBAAyB,SAAQ,WAAW;gBACzC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,aAAc,SAAQ,WAAW;gBAC9B,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,uBAAwB,SAAQ,WAAW;gBACxC,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,YAAa,SAAQ,WAAW;gBAC7B,OAAO,EAAE,MAAM;CAG9B;AA4CD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAcpD"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { DB, OpenOptions } from './types';
+export declare function openDB(name: string, options?: OpenOptions): Promise<DB>;
+export declare function deleteDB(name: string): Promise<void>;
+export declare function unsafeDebugCrashWorker(name: string): boolean;
+export * from './codec';
+export * from './errors';
+export * from './indexing';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAMR,EAAE,EAMF,WAAW,EASd,MAAM,SAAS,CAAC;AA6xBjB,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,EAAE,CAAC,CA2DjF;AACD,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1D;AACD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAG5D;AACD,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,mBAAmB,SAAS,CAAC"}

package/dist/indexing.d.ts

@@ -0,0 +1,33 @@
+import type { IndexDef, Range } from './types';
+export declare const INDEX_METADATA_STORE = "__browserdb:indexes";
+export interface NormalizedIndexDef {
+    store: string;
+    name: string;
+    keyPath: string[];
+    compound: boolean;
+    unique: boolean;
+    internalStore: string;
+}
+export interface DecodedIndexEntryKey {
+    logicalKey: Uint8Array;
+    primaryKey: Uint8Array;
+}
+export declare function isInternalStoreName(name: string): boolean;
+export declare function assertPublicStoreName(name: string): void;
+export declare function normalizeIndexDefinitions(value: unknown): NormalizedIndexDef[];
+export declare function compareNormalizedIndexDefinitions(left: NormalizedIndexDef, right: NormalizedIndexDef): number;
+export declare function indexDefinitionIdentity(store: string, name: string): string;
+export declare function findIndexDefinition(defs: ReadonlyArray<NormalizedIndexDef>, store: string, name: string): NormalizedIndexDef | null;
+export declare function indexesForStore(defs: ReadonlyArray<NormalizedIndexDef>, store: string): NormalizedIndexDef[];
+export declare function encodeIndexMetadataKey(store: string, name: string): Uint8Array;
+export declare function encodeIndexMetadataValue(def: NormalizedIndexDef): Uint8Array;
+export declare function decodeIndexMetadataValue(bytes: Uint8Array): NormalizedIndexDef;
+export declare function encodeIndexEntryKey(logicalIndexKey: Uint8Array, primaryKey: Uint8Array): Uint8Array;
+export declare function decodeIndexEntryKey(bytes: Uint8Array): DecodedIndexEntryKey;
+export declare function indexKeyExactRange(logicalIndexKey: Uint8Array): Range;
+export declare function indexRangeToPhysicalRange(range?: Range): Range;
+export declare function extractLogicalIndexKey(def: NormalizedIndexDef, valueBytes: Uint8Array): Uint8Array | null;
+export declare function serializeNormalizedIndexDefinitions(defs: ReadonlyArray<NormalizedIndexDef>): string;
+export declare function cloneNormalizedIndexDefinitions(defs: ReadonlyArray<NormalizedIndexDef>): NormalizedIndexDef[];
+export declare function toPublicIndexDefinitions(defs: ReadonlyArray<NormalizedIndexDef>): IndexDef[];
+//# sourceMappingURL=indexing.d.ts.map

package/dist/indexing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexing.d.ts","sourceRoot":"","sources":["../src/indexing.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAU/C,eAAO,MAAM,oBAAoB,wBAAwB,CAAC;AAC1D,MAAM,WAAW,kBAAkB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;CACzB;AACD,MAAM,WAAW,oBAAoB;IACjC,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,UAAU,CAAC;CAC1B;AACD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AACD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAIxD;AACD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,kBAAkB,EAAE,CAuD9E;AACD,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAc7G;AACD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3E;AACD,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,aAAa,CAAC,kBAAkB,CAAC,EACvC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACb,kBAAkB,GAAG,IAAI,CAE3B;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,CAAC,kBAAkB,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAE5G;AACD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAE9E;AACD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,kBAAkB,GAAG,UAAU,CAE5E;AACD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,UAAU,GAAG,kBAAkB,CAS9E;AACD,wBAAgB,mBAAmB,CAAC,eAAe,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,GAAG,UAAU,CAEnG;AACD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,oBAAoB,CAS3E;AACD,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,UAAU,GAAG,KAAK,CAErE;AACD,wBAAgB,yBAAyB,CAAC,KAAK,GAAE,KAAU,GAAG,KAAK,CA4BlE;AACD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,kBAAkB,EAAE,UAAU,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI,CAkBzG;AACD,wBAAgB,mCAAmC,CAAC,IAAI,EAAE,aAAa,CAAC,kBAAkB,CAAC,GAAG,MAAM,CAEnG;AACD,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,aAAa,CAAC,kBAAkB,CAAC,GAAG,kBAAkB,EAAE,CAS7G;AACD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,CAAC,kBAAkB,CAAC,GAAG,QAAQ,EAAE,CAE5F"}

package/dist/internal.d.ts

@@ -0,0 +1,4 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function compareStringsByCodeUnit(left: string, right: string): number;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, fallback: T): Promise<T>;
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK5E;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAc9F"}