@loradb/lora-wasm 0.5.6 → 0.6.0

package/pkg-bundler/package.json

@@ -5,7 +5,7 @@
     "LoraDB, Inc."
   ],
   "description": "WebAssembly bindings for the Lora in-memory graph database",
-  "version": "0.5.6",
+  "version": "0.6.0",
   "license": "BUSL-1.1",
   "files": [
     "lora_wasm_bg.wasm",

package/pkg-node/README.md

@@ -116,14 +116,17 @@ useful for tests and for swapping execution backends behind the same API.
 
 ## Snapshots
 
-WASM has no filesystem access, so `saveSnapshot()` defaults to a `Uint8Array`.
-It also accepts typed formats: `"base64"` returns base64 text, `"blob"` returns
-a `Blob`, and `"download"` triggers a browser download from the main thread.
-
-`loadSnapshot` accepts a `WasmSnapshotSource`: `Uint8Array`, `ArrayBuffer`,
-`Blob`/`File`, `Response`, web `ReadableStream`, string URL, or `URL`. It does
-not include Node `Buffer`; use `Uint8Array` bytes when running the WASM package
-from Node.
+WASM has no filesystem access, so snapshots never accept string paths.
+`saveSnapshot()` defaults to `Uint8Array`, and can also return `ArrayBuffer`,
+`Blob`, `Response`, `ReadableStream`, or an object `URL`. `loadSnapshot`
+accepts `URL`, `Uint8Array`, `ArrayBuffer`, `Blob`, `Response`, and web
+`ReadableStream<Uint8Array | ArrayBuffer>`. The bytes use the database
+snapshot codec (`LORACOL1`) and can be loaded by native LoraDB. Older store
+snapshots (`LORASNAP`) are still accepted by `loadSnapshot` for compatibility.
+Snapshot bytes are uncompressed by default; pass `{ compression: "gzip" }` or
+`{ compression: { format: "gzip", level: 1 } }` to save smaller
+WASM-portable snapshots. Gzip levels `0..9` are supported; level `1` is the
+fast default.
 
 ```ts
 import { createDatabase } from "lora-wasm";
@@ -131,20 +134,18 @@ import { createDatabase } from "lora-wasm";
 const db = await createDatabase();
 await db.execute("CREATE (:Person {name: 'Alice'})");
 
-const bytes = await db.saveSnapshotToBytes();
-const sameBytes = await db.saveSnapshot("binary");
-const blob = await db.saveSnapshot({ format: "blob" });
-await db.saveSnapshot({ format: "download", filename: "graph.lorasnap" });
+const bytes = await db.saveSnapshot();
+const compressed = await db.saveSnapshot({ compression: "gzip" });
+const blob = await db.saveSnapshot({ format: "blob", compression: "gzip" });
+const response = await db.saveSnapshot({ format: "response" });
 
 await db.loadSnapshot(bytes);
+await db.loadSnapshot(compressed);
 await db.loadSnapshot(blob);
-await db.loadSnapshot(new Response(bytes).body!);
+await db.loadSnapshot(response);
 await db.loadSnapshot(new URL("/graph.lorasnap", location.href));
 ```
 
-`loadSnapshotFromBytes(bytes)` remains available for the narrow
-`Uint8Array`-only path.
-
 ## Typed value model
 
 | TS type                              | Runtime shape                                                               |

package/pkg-node/lora_wasm.d.ts

@@ -21,23 +21,25 @@ export class WasmDatabase {
    * transaction. Returns an array of query results in statement order.
    */
   transaction(statements: any, mode?: string | null): any;
-  relationshipCount(): number;
   /**
-   * Serialize the graph into a byte buffer. The caller is responsible for
-   * writing it to disk, IndexedDB, localStorage, or wherever — WASM does
-   * not have direct filesystem access. The returned bytes can later be
-   * passed to `loadSnapshotFromBytes` on any `WasmDatabase` instance.
+   * Replace the graph state with a database snapshot decoded from `bytes`.
+   * Legacy store snapshot bytes are accepted for compatibility.
    *
-   * Returns the serialized bytes as a `Uint8Array`.
+   * Returns a plain object matching the shape of `SnapshotMeta`:
+   * `{ formatVersion, nodeCount, relationshipCount, walLsn }`.
    */
-  saveSnapshotToBytes(): Uint8Array;
+  loadSnapshot(bytes: Uint8Array, options: any): any;
   /**
-   * Replace the graph state with a snapshot decoded from `bytes`.
+   * Serialize the graph into database snapshot bytes. The caller is
+   * responsible for writing them to IndexedDB, localStorage, a server, or
+   * another host-provided store — WASM has no direct filesystem access.
+   * The returned bytes can later be passed to `loadSnapshot` on any
+   * `WasmDatabase` instance.
    *
-   * Returns a plain object matching the shape of `SnapshotMeta`:
-   * `{ formatVersion, nodeCount, relationshipCount, walLsn }`.
+   * Returns the serialized bytes as a `Uint8Array`.
    */
-  loadSnapshotFromBytes(bytes: Uint8Array): any;
+  saveSnapshot(options: any): Uint8Array;
+  relationshipCount(): number;
   constructor();
   clear(): void;
   /**

package/pkg-node/lora_wasm.js

@@ -177,17 +177,17 @@ function takeFromExternrefTable0(idx) {
     return value;
 }
 
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
 /**
  * Call once at module start to install a panic hook that routes Rust
  * panics to `console.error`. No-op if compiled without the default feature.
@@ -255,23 +255,37 @@ class WasmDatabase {
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @returns {number}
+     * Replace the graph state with a database snapshot decoded from `bytes`.
+     * Legacy store snapshot bytes are accepted for compatibility.
+     *
+     * Returns a plain object matching the shape of `SnapshotMeta`:
+     * `{ formatVersion, nodeCount, relationshipCount, walLsn }`.
+     * @param {Uint8Array} bytes
+     * @param {any} options
+     * @returns {any}
      */
-    relationshipCount() {
-        const ret = wasm.wasmdatabase_relationshipCount(this.__wbg_ptr);
-        return ret >>> 0;
+    loadSnapshot(bytes, options) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmdatabase_loadSnapshot(this.__wbg_ptr, ptr0, len0, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Serialize the graph into a byte buffer. The caller is responsible for
-     * writing it to disk, IndexedDB, localStorage, or wherever — WASM does
-     * not have direct filesystem access. The returned bytes can later be
-     * passed to `loadSnapshotFromBytes` on any `WasmDatabase` instance.
+     * Serialize the graph into database snapshot bytes. The caller is
+     * responsible for writing them to IndexedDB, localStorage, a server, or
+     * another host-provided store — WASM has no direct filesystem access.
+     * The returned bytes can later be passed to `loadSnapshot` on any
+     * `WasmDatabase` instance.
      *
      * Returns the serialized bytes as a `Uint8Array`.
+     * @param {any} options
      * @returns {Uint8Array}
      */
-    saveSnapshotToBytes() {
-        const ret = wasm.wasmdatabase_saveSnapshotToBytes(this.__wbg_ptr);
+    saveSnapshot(options) {
+        const ret = wasm.wasmdatabase_saveSnapshot(this.__wbg_ptr, options);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -280,21 +294,11 @@ class WasmDatabase {
         return v1;
     }
     /**
-     * Replace the graph state with a snapshot decoded from `bytes`.
-     *
-     * Returns a plain object matching the shape of `SnapshotMeta`:
-     * `{ formatVersion, nodeCount, relationshipCount, walLsn }`.
-     * @param {Uint8Array} bytes
-     * @returns {any}
+     * @returns {number}
      */
-    loadSnapshotFromBytes(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmdatabase_loadSnapshotFromBytes(this.__wbg_ptr, ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
+    relationshipCount() {
+        const ret = wasm.wasmdatabase_relationshipCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     constructor() {
         const ret = wasm.wasmdatabase_new();
@@ -396,6 +400,16 @@ module.exports.__wbg_call_672a4d21634d4a24 = function() { return handleError(fun
     return ret;
 }, arguments) };
 
+module.exports.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_crypto_86f2631e91b51511 = function(arg0) {
+    const ret = arg0.crypto;
+    return ret;
+};
+
 module.exports.__wbg_done_769e5ede4b31c67b = function(arg0) {
     const ret = arg0.done;
     return ret;
@@ -418,6 +432,10 @@ module.exports.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
     }
 };
 
+module.exports.__wbg_getRandomValues_b3f15fcbfabb0f8b = function() { return handleError(function (arg0, arg1) {
+    arg0.getRandomValues(arg1);
+}, arguments) };
+
 module.exports.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(arg0, arg1);
     return ret;
@@ -486,6 +504,11 @@ module.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) {
     return ret;
 };
 
+module.exports.__wbg_msCrypto_d562bbe83e0d4b91 = function(arg0) {
+    const ret = arg0.msCrypto;
+    return ret;
+};
+
 module.exports.__wbg_new_405e22f390576ce2 = function() {
     const ret = new Object();
     return ret;
@@ -511,6 +534,21 @@ module.exports.__wbg_new_a12002a7f91c75be = function(arg0) {
     return ret;
 };
 
+module.exports.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+module.exports.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
+    const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+    return ret;
+};
+
+module.exports.__wbg_newwithlength_a381634e90c276d4 = function(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+};
+
 module.exports.__wbg_next_25feadfc0913fea9 = function(arg0) {
     const ret = arg0.next;
     return ret;
@@ -521,11 +559,30 @@ module.exports.__wbg_next_6574e1a8a62d1055 = function() { return handleError(fun
     return ret;
 }, arguments) };
 
+module.exports.__wbg_node_e1f24f89a7336c2e = function(arg0) {
+    const ret = arg0.node;
+    return ret;
+};
+
 module.exports.__wbg_now_807e54c39636c349 = function() {
     const ret = Date.now();
     return ret;
 };
 
+module.exports.__wbg_process_3975fd6c72f520aa = function(arg0) {
+    const ret = arg0.process;
+    return ret;
+};
+
+module.exports.__wbg_randomFillSync_f8c153b79f285817 = function() { return handleError(function (arg0, arg1) {
+    arg0.randomFillSync(arg1);
+}, arguments) };
+
+module.exports.__wbg_require_b74f47fc2d022fd6 = function() { return handleError(function () {
+    const ret = module.require;
+    return ret;
+}, arguments) };
+
 module.exports.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
     arg0[arg1 >>> 0] = arg2;
 };
@@ -551,11 +608,41 @@ module.exports.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
+module.exports.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+module.exports.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+module.exports.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+module.exports.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+module.exports.__wbg_subarray_aa9065fa9dc5df96 = function(arg0, arg1, arg2) {
+    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+    return ret;
+};
+
 module.exports.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) {
     const ret = arg0.value;
     return ret;
 };
 
+module.exports.__wbg_versions_4e31226f5e8dc909 = function(arg0) {
+    const ret = arg0.versions;
+    return ret;
+};
+
 module.exports.__wbindgen_bigint_from_i64 = function(arg0) {
     const ret = arg0;
     return ret;

package/pkg-node/lora_wasm_bg.wasm.d.ts

@@ -5,12 +5,12 @@ export const __wbg_wasmdatabase_free: (a: number, b: number) => void;
 export const __wbg_wasmquerystream_free: (a: number, b: number) => void;
 export const wasmdatabase_clear: (a: number) => void;
 export const wasmdatabase_execute: (a: number, b: number, c: number, d: any) => [number, number, number];
-export const wasmdatabase_loadSnapshotFromBytes: (a: number, b: number, c: number) => [number, number, number];
+export const wasmdatabase_loadSnapshot: (a: number, b: number, c: number, d: any) => [number, number, number];
 export const wasmdatabase_new: () => number;
 export const wasmdatabase_nodeCount: (a: number) => number;
 export const wasmdatabase_openStream: (a: number, b: number, c: number, d: any) => [number, number, number];
 export const wasmdatabase_relationshipCount: (a: number) => number;
-export const wasmdatabase_saveSnapshotToBytes: (a: number) => [number, number, number, number];
+export const wasmdatabase_saveSnapshot: (a: number, b: any) => [number, number, number, number];
 export const wasmdatabase_transaction: (a: number, b: any, c: number, d: number) => [number, number, number];
 export const wasmquerystream_close: (a: number) => void;
 export const wasmquerystream_columns: (a: number) => [number, number, number];

package/pkg-node/package.json

@@ -4,7 +4,7 @@
     "LoraDB, Inc."
   ],
   "description": "WebAssembly bindings for the Lora in-memory graph database",
-  "version": "0.5.6",
+  "version": "0.6.0",
   "license": "BUSL-1.1",
   "files": [
     "lora_wasm_bg.wasm",

package/pkg-web/README.md

@@ -116,14 +116,17 @@ useful for tests and for swapping execution backends behind the same API.
 
 ## Snapshots
 
-WASM has no filesystem access, so `saveSnapshot()` defaults to a `Uint8Array`.
-It also accepts typed formats: `"base64"` returns base64 text, `"blob"` returns
-a `Blob`, and `"download"` triggers a browser download from the main thread.
-
-`loadSnapshot` accepts a `WasmSnapshotSource`: `Uint8Array`, `ArrayBuffer`,
-`Blob`/`File`, `Response`, web `ReadableStream`, string URL, or `URL`. It does
-not include Node `Buffer`; use `Uint8Array` bytes when running the WASM package
-from Node.
+WASM has no filesystem access, so snapshots never accept string paths.
+`saveSnapshot()` defaults to `Uint8Array`, and can also return `ArrayBuffer`,
+`Blob`, `Response`, `ReadableStream`, or an object `URL`. `loadSnapshot`
+accepts `URL`, `Uint8Array`, `ArrayBuffer`, `Blob`, `Response`, and web
+`ReadableStream<Uint8Array | ArrayBuffer>`. The bytes use the database
+snapshot codec (`LORACOL1`) and can be loaded by native LoraDB. Older store
+snapshots (`LORASNAP`) are still accepted by `loadSnapshot` for compatibility.
+Snapshot bytes are uncompressed by default; pass `{ compression: "gzip" }` or
+`{ compression: { format: "gzip", level: 1 } }` to save smaller
+WASM-portable snapshots. Gzip levels `0..9` are supported; level `1` is the
+fast default.
 
 ```ts
 import { createDatabase } from "lora-wasm";
@@ -131,20 +134,18 @@ import { createDatabase } from "lora-wasm";
 const db = await createDatabase();
 await db.execute("CREATE (:Person {name: 'Alice'})");
 
-const bytes = await db.saveSnapshotToBytes();
-const sameBytes = await db.saveSnapshot("binary");
-const blob = await db.saveSnapshot({ format: "blob" });
-await db.saveSnapshot({ format: "download", filename: "graph.lorasnap" });
+const bytes = await db.saveSnapshot();
+const compressed = await db.saveSnapshot({ compression: "gzip" });
+const blob = await db.saveSnapshot({ format: "blob", compression: "gzip" });
+const response = await db.saveSnapshot({ format: "response" });
 
 await db.loadSnapshot(bytes);
+await db.loadSnapshot(compressed);
 await db.loadSnapshot(blob);
-await db.loadSnapshot(new Response(bytes).body!);
+await db.loadSnapshot(response);
 await db.loadSnapshot(new URL("/graph.lorasnap", location.href));
 ```
 
-`loadSnapshotFromBytes(bytes)` remains available for the narrow
-`Uint8Array`-only path.
-
 ## Typed value model
 
 | TS type                              | Runtime shape                                                               |

package/pkg-web/lora_wasm.d.ts

@@ -21,23 +21,25 @@ export class WasmDatabase {
    * transaction. Returns an array of query results in statement order.
    */
   transaction(statements: any, mode?: string | null): any;
-  relationshipCount(): number;
   /**
-   * Serialize the graph into a byte buffer. The caller is responsible for
-   * writing it to disk, IndexedDB, localStorage, or wherever — WASM does
-   * not have direct filesystem access. The returned bytes can later be
-   * passed to `loadSnapshotFromBytes` on any `WasmDatabase` instance.
+   * Replace the graph state with a database snapshot decoded from `bytes`.
+   * Legacy store snapshot bytes are accepted for compatibility.
    *
-   * Returns the serialized bytes as a `Uint8Array`.
+   * Returns a plain object matching the shape of `SnapshotMeta`:
+   * `{ formatVersion, nodeCount, relationshipCount, walLsn }`.
    */
-  saveSnapshotToBytes(): Uint8Array;
+  loadSnapshot(bytes: Uint8Array, options: any): any;
   /**
-   * Replace the graph state with a snapshot decoded from `bytes`.
+   * Serialize the graph into database snapshot bytes. The caller is
+   * responsible for writing them to IndexedDB, localStorage, a server, or
+   * another host-provided store — WASM has no direct filesystem access.
+   * The returned bytes can later be passed to `loadSnapshot` on any
+   * `WasmDatabase` instance.
    *
-   * Returns a plain object matching the shape of `SnapshotMeta`:
-   * `{ formatVersion, nodeCount, relationshipCount, walLsn }`.
+   * Returns the serialized bytes as a `Uint8Array`.
    */
-  loadSnapshotFromBytes(bytes: Uint8Array): any;
+  saveSnapshot(options: any): Uint8Array;
+  relationshipCount(): number;
   constructor();
   clear(): void;
   /**
@@ -65,12 +67,12 @@ export interface InitOutput {
   readonly __wbg_wasmquerystream_free: (a: number, b: number) => void;
   readonly wasmdatabase_clear: (a: number) => void;
   readonly wasmdatabase_execute: (a: number, b: number, c: number, d: any) => [number, number, number];
-  readonly wasmdatabase_loadSnapshotFromBytes: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmdatabase_loadSnapshot: (a: number, b: number, c: number, d: any) => [number, number, number];
   readonly wasmdatabase_new: () => number;
   readonly wasmdatabase_nodeCount: (a: number) => number;
   readonly wasmdatabase_openStream: (a: number, b: number, c: number, d: any) => [number, number, number];
   readonly wasmdatabase_relationshipCount: (a: number) => number;
-  readonly wasmdatabase_saveSnapshotToBytes: (a: number) => [number, number, number, number];
+  readonly wasmdatabase_saveSnapshot: (a: number, b: any) => [number, number, number, number];
   readonly wasmdatabase_transaction: (a: number, b: any, c: number, d: number) => [number, number, number];
   readonly wasmquerystream_close: (a: number) => void;
   readonly wasmquerystream_columns: (a: number) => [number, number, number];