rvlite 0.2.1 → 0.2.2

package/dist/index.js

@@ -0,0 +1,2123 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/wasm/rvlite.js
+var rvlite_exports = {};
+__export(rvlite_exports, {
+  CypherEngine: () => CypherEngine,
+  RvLite: () => RvLite,
+  RvLiteConfig: () => RvLiteConfig,
+  default: () => rvlite_default,
+  init: () => init,
+  initSync: () => initSync
+});
+function addHeapObject(obj) {
+  if (heap_next === heap.length) heap.push(heap.length + 1);
+  const idx = heap_next;
+  heap_next = heap[idx];
+  heap[idx] = obj;
+  return idx;
+}
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+function debugString(val) {
+  const type = typeof val;
+  if (type == "number" || type == "boolean" || val == null) {
+    return `${val}`;
+  }
+  if (type == "string") {
+    return `"${val}"`;
+  }
+  if (type == "symbol") {
+    const description = val.description;
+    if (description == null) {
+      return "Symbol";
+    } else {
+      return `Symbol(${description})`;
+    }
+  }
+  if (type == "function") {
+    const name = val.name;
+    if (typeof name == "string" && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return "Function";
+    }
+  }
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = "[";
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1; i < length; i++) {
+      debug += ", " + debugString(val[i]);
+    }
+    debug += "]";
+    return debug;
+  }
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}
+${val.stack}`;
+  }
+  return className;
+}
+function dropObject(idx) {
+  if (idx < 132) return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getFloat32ArrayMemory0() {
+  if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+    cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+  }
+  return cachedFloat32ArrayMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function getObject(idx) {
+  return heap[idx];
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    wasm.__wbindgen_export3(addHeapObject(e));
+  }
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function makeMutClosure(arg0, arg1, dtor, f) {
+  const state = { a: arg0, b: arg1, cnt: 1, dtor };
+  const real = (...args) => {
+    state.cnt++;
+    const a = state.a;
+    state.a = 0;
+    try {
+      return f(a, state.b, ...args);
+    } finally {
+      state.a = a;
+      real._wbg_cb_unref();
+    }
+  };
+  real._wbg_cb_unref = () => {
+    if (--state.cnt === 0) {
+      state.dtor(state.a, state.b);
+      state.a = 0;
+      CLOSURE_DTORS.unregister(state);
+    }
+  };
+  CLOSURE_DTORS.register(real, state, state);
+  return real;
+}
+function passArrayF32ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 4, 4) >>> 0;
+  getFloat32ArrayMemory0().set(arg, ptr / 4);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeObject(idx) {
+  const ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+function __wasm_bindgen_func_elem_1339(arg0, arg1, arg2) {
+  wasm.__wasm_bindgen_func_elem_1339(arg0, arg1, addHeapObject(arg2));
+}
+function __wasm_bindgen_func_elem_180(arg0, arg1, arg2) {
+  wasm.__wasm_bindgen_func_elem_180(arg0, arg1, addHeapObject(arg2));
+}
+function __wasm_bindgen_func_elem_1385(arg0, arg1, arg2, arg3) {
+  wasm.__wasm_bindgen_func_elem_1385(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+function init() {
+  wasm.init();
+}
+async function __wbg_load(module2, imports) {
+  if (typeof Response === "function" && module2 instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module2, imports);
+      } catch (e) {
+        const validResponse = module2.ok && EXPECTED_RESPONSE_TYPES.has(module2.type);
+        if (validResponse && module2.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module2.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module2, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module: module2 };
+    } else {
+      return instance;
+    }
+  }
+}
+function __wbg_get_imports() {
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_Number_2d1dcfcf4ec51736 = function(arg0) {
+    const ret = Number(getObject(arg0));
+    return ret;
+  };
+  imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+    const ret = String(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg___wbindgen_bigint_get_as_i64_6e32f5e6aff02e1d = function(arg0, arg1) {
+    const v = getObject(arg1);
+    const ret = typeof v === "bigint" ? v : void 0;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+  };
+  imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+    const v = getObject(arg0);
+    const ret = typeof v === "boolean" ? v : void 0;
+    return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
+  };
+  imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
+    const ret = debugString(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg___wbindgen_in_0d3e1e8f0c669317 = function(arg0, arg1) {
+    const ret = getObject(arg0) in getObject(arg1);
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_bigint_0e1a2e3f55cfae27 = function(arg0) {
+    const ret = typeof getObject(arg0) === "bigint";
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
+    const ret = typeof getObject(arg0) === "function";
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_null_dfda7d66506c95b5 = function(arg0) {
+    const ret = getObject(arg0) === null;
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
+    const val = getObject(arg0);
+    const ret = typeof val === "object" && val !== null;
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_string_704ef9c8fc131030 = function(arg0) {
+    const ret = typeof getObject(arg0) === "string";
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+    const ret = getObject(arg0) === void 0;
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_jsval_eq_b6101cc9cef1fe36 = function(arg0, arg1) {
+    const ret = getObject(arg0) === getObject(arg1);
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_jsval_loose_eq_766057600fdd1b0d = function(arg0, arg1) {
+    const ret = getObject(arg0) == getObject(arg1);
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof obj === "number" ? obj : void 0;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+  };
+  imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof obj === "string" ? obj : void 0;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  imports.wbg.__wbg__wbg_cb_unref_87dfb5aaa0cbcea7 = function(arg0) {
+    getObject(arg0)._wbg_cb_unref();
+  };
+  imports.wbg.__wbg_call_3020136f7a2d6e44 = function() {
+    return handleError(function(arg0, arg1, arg2) {
+      const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_call_abb4ff46ce38be40 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = getObject(arg0).call(getObject(arg1));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_clear_0e6ff4790cdabf11 = function() {
+    return handleError(function(arg0) {
+      const ret = getObject(arg0).clear();
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_close_cf7ef4e294ac3858 = function(arg0) {
+    getObject(arg0).close();
+  };
+  imports.wbg.__wbg_contains_de2a27de1ed31877 = function(arg0, arg1, arg2) {
+    const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
+    return ret;
+  };
+  imports.wbg.__wbg_count_5aeeb43c8c540e73 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = getObject(arg0).count(getObject(arg1));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_createObjectStore_dba64acfe84d4191 = function() {
+    return handleError(function(arg0, arg1, arg2) {
+      const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
+    const ret = getObject(arg0).done;
+    return ret;
+  };
+  imports.wbg.__wbg_entries_83c79938054e065f = function(arg0) {
+    const ret = Object.entries(getObject(arg0));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+      deferred0_0 = arg0;
+      deferred0_1 = arg1;
+      console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+      wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
+    }
+  };
+  imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_get_7d8b665fa88606d5 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = getObject(arg0).get(getObject(arg1));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_get_af9dab7e9603ea93 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = Reflect.get(getObject(arg0), getObject(arg1));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_get_with_ref_key_1dc361bd10053bfe = function(arg0, arg1) {
+    const ret = getObject(arg0)[getObject(arg1)];
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_indexedDB_23c232e00a1e28ad = function() {
+    return handleError(function(arg0) {
+      const ret = getObject(arg0).indexedDB;
+      return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_instanceof_ArrayBuffer_f3320d2419cd0355 = function(arg0) {
+    let result;
+    try {
+      result = getObject(arg0) instanceof ArrayBuffer;
+    } catch (_) {
+      result = false;
+    }
+    const ret = result;
+    return ret;
+  };
+  imports.wbg.__wbg_instanceof_Map_084be8da74364158 = function(arg0) {
+    let result;
+    try {
+      result = getObject(arg0) instanceof Map;
+    } catch (_) {
+      result = false;
+    }
+    const ret = result;
+    return ret;
+  };
+  imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
+    let result;
+    try {
+      result = getObject(arg0) instanceof Uint8Array;
+    } catch (_) {
+      result = false;
+    }
+    const ret = result;
+    return ret;
+  };
+  imports.wbg.__wbg_instanceof_Window_b5cf7783caa68180 = function(arg0) {
+    let result;
+    try {
+      result = getObject(arg0) instanceof Window;
+    } catch (_) {
+      result = false;
+    }
+    const ret = result;
+    return ret;
+  };
+  imports.wbg.__wbg_isArray_51fd9e6422c0a395 = function(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+  };
+  imports.wbg.__wbg_isSafeInteger_ae7d3f054d55fa16 = function(arg0) {
+    const ret = Number.isSafeInteger(getObject(arg0));
+    return ret;
+  };
+  imports.wbg.__wbg_iterator_27b7c8b35ab3e86b = function() {
+    const ret = Symbol.iterator;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+  };
+  imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+  };
+  imports.wbg.__wbg_log_1d990106d99dacb7 = function(arg0) {
+    console.log(getObject(arg0));
+  };
+  imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
+    const ret = new Object();
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_25f239778d6112b9 = function() {
+    const ret = new Array();
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
+    const ret = new Uint8Array(getObject(arg0));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+    const ret = new Error();
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_b546ae120718850e = function() {
+    const ret = /* @__PURE__ */ new Map();
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
+    try {
+      var state0 = { a: arg0, b: arg1 };
+      var cb0 = (arg02, arg12) => {
+        const a = state0.a;
+        state0.a = 0;
+        try {
+          return __wasm_bindgen_func_elem_1385(a, state0.b, arg02, arg12);
+        } finally {
+          state0.a = a;
+        }
+      };
+      const ret = new Promise(cb0);
+      return addHeapObject(ret);
+    } finally {
+      state0.a = state0.b = 0;
+    }
+  };
+  imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_next_138a17bbf04e926c = function(arg0) {
+    const ret = getObject(arg0).next;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_next_3cfe5c0fe2a4cc53 = function() {
+    return handleError(function(arg0) {
+      const ret = getObject(arg0).next();
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_now_69d776cd24f5215b = function() {
+    const ret = Date.now();
+    return ret;
+  };
+  imports.wbg.__wbg_objectStoreNames_90900f9a531513ac = function(arg0) {
+    const ret = getObject(arg0).objectStoreNames;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_objectStore_da9a077b8849dbe9 = function() {
+    return handleError(function(arg0, arg1, arg2) {
+      const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_open_0d7b85f4c0a38ffe = function() {
+    return handleError(function(arg0, arg1, arg2, arg3) {
+      const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_parse_a09a54cf72639456 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+  };
+  imports.wbg.__wbg_push_7d9be8f38fc13975 = function(arg0, arg1) {
+    const ret = getObject(arg0).push(getObject(arg1));
+    return ret;
+  };
+  imports.wbg.__wbg_put_d40a68e5a8902a46 = function() {
+    return handleError(function(arg0, arg1, arg2) {
+      const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_queueMicrotask_9b549dfce8865860 = function(arg0) {
+    const ret = getObject(arg0).queueMicrotask;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_queueMicrotask_fca69f5bfad613a5 = function(arg0) {
+    queueMicrotask(getObject(arg0));
+  };
+  imports.wbg.__wbg_resolve_fd5bfbaa4ce36e1e = function(arg0) {
+    const ret = Promise.resolve(getObject(arg0));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_result_084f962aedb54250 = function() {
+    return handleError(function(arg0) {
+      const ret = getObject(arg0).result;
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+  };
+  imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
+    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+  };
+  imports.wbg.__wbg_set_efaaf145b9377369 = function(arg0, arg1, arg2) {
+    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_set_onerror_08fecec3bdc9d24d = function(arg0, arg1) {
+    getObject(arg0).onerror = getObject(arg1);
+  };
+  imports.wbg.__wbg_set_onsuccess_94332a00452de699 = function(arg0, arg1) {
+    getObject(arg0).onsuccess = getObject(arg1);
+  };
+  imports.wbg.__wbg_set_onupgradeneeded_3dc6e233a6d13fe2 = function(arg0, arg1) {
+    getObject(arg0).onupgradeneeded = getObject(arg1);
+  };
+  imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
+    const ret = typeof global === "undefined" ? null : global;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+  };
+  imports.wbg.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
+    const ret = typeof globalThis === "undefined" ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+  };
+  imports.wbg.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
+    const ret = typeof self === "undefined" ? null : self;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+  };
+  imports.wbg.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
+    const ret = typeof window === "undefined" ? null : window;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+  };
+  imports.wbg.__wbg_target_0e3e05a6263c37a0 = function(arg0) {
+    const ret = getObject(arg0).target;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+  };
+  imports.wbg.__wbg_then_429f7caf1026411d = function(arg0, arg1, arg2) {
+    const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_then_4f95312d68691235 = function(arg0, arg1) {
+    const ret = getObject(arg0).then(getObject(arg1));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_transaction_257422def49a0094 = function() {
+    return handleError(function(arg0, arg1, arg2) {
+      const ret = getObject(arg0).transaction(getObject(arg1), __wbindgen_enum_IdbTransactionMode[arg2]);
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_transaction_754344c3ae25fdcf = function() {
+    return handleError(function(arg0, arg1, arg2) {
+      const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
+    const ret = getObject(arg0).value;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+    const ret = BigInt.asUintN(64, arg0);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_cast_59e89726c7c5a9af = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_179, __wasm_bindgen_func_elem_180);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_cast_8ff99cee1f2c383b = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1338, __wasm_bindgen_func_elem_1339);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+    const ret = arg0;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+    const ret = arg0;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+    const ret = getObject(arg0);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+    takeObject(arg0);
+  };
+  return imports;
+}
+function __wbg_finalize_init(instance, module2) {
+  wasm = instance.exports;
+  __wbg_init.__wbindgen_wasm_module = module2;
+  cachedDataViewMemory0 = null;
+  cachedFloat32ArrayMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+function initSync(module2) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module2 !== "undefined") {
+    if (Object.getPrototypeOf(module2) === Object.prototype) {
+      ({ module: module2 } = module2);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  if (!(module2 instanceof WebAssembly.Module)) {
+    module2 = new WebAssembly.Module(module2);
+  }
+  const instance = new WebAssembly.Instance(module2, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module_or_path !== "undefined") {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (typeof module_or_path === "undefined") {
+    module_or_path = new URL("rvlite_bg.wasm", import_meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+var import_meta, wasm, CLOSURE_DTORS, cachedDataViewMemory0, cachedFloat32ArrayMemory0, cachedUint8ArrayMemory0, heap, heap_next, cachedTextDecoder, MAX_SAFARI_DECODE_BYTES, numBytesDecoded, cachedTextEncoder, WASM_VECTOR_LEN, __wbindgen_enum_IdbTransactionMode, CypherEngineFinalization, RvLiteFinalization, RvLiteConfigFinalization, CypherEngine, RvLite, RvLiteConfig, EXPECTED_RESPONSE_TYPES, rvlite_default;
+var init_rvlite = __esm({
+  "dist/wasm/rvlite.js"() {
+    "use strict";
+    import_meta = {};
+    CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((state) => state.dtor(state.a, state.b));
+    cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    heap = new Array(128).fill(void 0);
+    heap.push(void 0, null, true, false);
+    heap_next = heap.length;
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    MAX_SAFARI_DECODE_BYTES = 2146435072;
+    numBytesDecoded = 0;
+    cachedTextEncoder = new TextEncoder();
+    if (!("encodeInto" in cachedTextEncoder)) {
+      cachedTextEncoder.encodeInto = function(arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+          read: arg.length,
+          written: buf.length
+        };
+      };
+    }
+    WASM_VECTOR_LEN = 0;
+    __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
+    CypherEngineFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_cypherengine_free(ptr >>> 0, 1));
+    RvLiteFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_rvlite_free(ptr >>> 0, 1));
+    RvLiteConfigFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_rvliteconfig_free(ptr >>> 0, 1));
+    CypherEngine = class {
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CypherEngineFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cypherengine_free(ptr, 0);
+      }
+      /**
+       * Create a new Cypher engine with empty graph
+       */
+      constructor() {
+        const ret = wasm.cypherengine_new();
+        this.__wbg_ptr = ret >>> 0;
+        CypherEngineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /**
+       * Clear the graph
+       */
+      clear() {
+        wasm.cypherengine_clear(this.__wbg_ptr);
+      }
+      /**
+       * Get graph statistics
+       * @returns {any}
+       */
+      stats() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.cypherengine_stats(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Execute a Cypher query and return JSON results
+       * @param {string} query
+       * @returns {any}
+       */
+      execute(query) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.cypherengine_execute(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+    };
+    if (Symbol.dispose) CypherEngine.prototype[Symbol.dispose] = CypherEngine.prototype.free;
+    RvLite = class _RvLite {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_RvLite.prototype);
+        obj.__wbg_ptr = ptr;
+        RvLiteFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RvLiteFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rvlite_free(ptr, 0);
+      }
+      /**
+       * Add an RDF triple
+       *
+       * # Arguments
+       * * `subject` - Subject IRI or blank node (e.g., "<http://example.org/s>" or "_:b1")
+       * * `predicate` - Predicate IRI (e.g., "<http://example.org/p>")
+       * * `object` - Object IRI, blank node, or literal (e.g., "<http://example.org/o>" or '"value"')
+       * @param {string} subject
+       * @param {string} predicate
+       * @param {string} object
+       */
+      add_triple(subject, predicate, object) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(subject, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+          const len0 = WASM_VECTOR_LEN;
+          const ptr1 = passStringToWasm0(predicate, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+          const len1 = WASM_VECTOR_LEN;
+          const ptr2 = passStringToWasm0(object, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+          const len2 = WASM_VECTOR_LEN;
+          wasm.rvlite_add_triple(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          if (r1) {
+            throw takeObject(r0);
+          }
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Get configuration
+       * @returns {any}
+       */
+      get_config() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.rvlite_get_config(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Export database state as JSON (for manual backup)
+       * @returns {any}
+       */
+      export_json() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.rvlite_export_json(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Get version string
+       * @returns {string}
+       */
+      get_version() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.rvlite_get_version(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          deferred1_0 = r0;
+          deferred1_1 = r1;
+          return getStringFromWasm0(r0, r1);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+          wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Import database state from JSON
+       * @param {any} json
+       */
+      import_json(json) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.rvlite_import_json(retptr, this.__wbg_ptr, addHeapObject(json));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          if (r1) {
+            throw takeObject(r0);
+          }
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Clear the Cypher graph
+       */
+      cypher_clear() {
+        wasm.rvlite_cypher_clear(this.__wbg_ptr);
+      }
+      /**
+       * Get Cypher graph statistics
+       * @returns {any}
+       */
+      cypher_stats() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.rvlite_cypher_stats(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Get enabled features
+       * @returns {any}
+       */
+      get_features() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.rvlite_get_features(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Initialize IndexedDB storage for persistence
+       * Must be called before save() or load()
+       * @returns {Promise<any>}
+       */
+      init_storage() {
+        const ret = wasm.rvlite_init_storage(this.__wbg_ptr);
+        return takeObject(ret);
+      }
+      /**
+       * Get the number of triples in the store
+       * @returns {number}
+       */
+      triple_count() {
+        const ret = wasm.rvlite_triple_count(this.__wbg_ptr);
+        return ret >>> 0;
+      }
+      /**
+       * Clear saved state from IndexedDB
+       * @returns {Promise<any>}
+       */
+      static clear_storage() {
+        const ret = wasm.rvlite_clear_storage();
+        return takeObject(ret);
+      }
+      /**
+       * Clear all triples
+       */
+      clear_triples() {
+        wasm.rvlite_clear_triples(this.__wbg_ptr);
+      }
+      /**
+       * Insert a vector with a specific ID
+       * @param {string} id
+       * @param {Float32Array} vector
+       * @param {any} metadata
+       */
+      insert_with_id(id, vector, metadata) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+          const len0 = WASM_VECTOR_LEN;
+          const ptr1 = passArrayF32ToWasm0(vector, wasm.__wbindgen_export);
+          const len1 = WASM_VECTOR_LEN;
+          wasm.rvlite_insert_with_id(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(metadata));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          if (r1) {
+            throw takeObject(r0);
+          }
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Check if saved state exists in IndexedDB
+       * @returns {Promise<any>}
+       */
+      static has_saved_state() {
+        const ret = wasm.rvlite_has_saved_state();
+        return takeObject(ret);
+      }
+      /**
+       * Search with metadata filter
+       * @param {Float32Array} query_vector
+       * @param {number} k
+       * @param {any} filter
+       * @returns {any}
+       */
+      search_with_filter(query_vector, k, filter) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passArrayF32ToWasm0(query_vector, wasm.__wbindgen_export);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.rvlite_search_with_filter(retptr, this.__wbg_ptr, ptr0, len0, k, addHeapObject(filter));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Check if IndexedDB is available in the browser
+       * @returns {boolean}
+       */
+      static is_storage_available() {
+        const ret = wasm.rvlite_is_storage_available();
+        return ret !== 0;
+      }
+      /**
+       * Get a vector by ID
+       * @param {string} id
+       * @returns {any}
+       */
+      get(id) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.rvlite_get(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Get the number of vectors in the database
+       * @returns {number}
+       */
+      len() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.rvlite_len(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return r0 >>> 0;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Create a new RvLite database
+       * @param {RvLiteConfig} config
+       */
+      constructor(config) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          _assertClass(config, RvLiteConfig);
+          var ptr0 = config.__destroy_into_raw();
+          wasm.rvlite_new(retptr, ptr0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          this.__wbg_ptr = r0 >>> 0;
+          RvLiteFinalization.register(this, this.__wbg_ptr, this);
+          return this;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Execute SQL query
+       *
+       * Supported syntax:
+       * - CREATE TABLE vectors (id TEXT PRIMARY KEY, vector VECTOR(384))
+       * - SELECT * FROM vectors WHERE id = 'x'
+       * - SELECT id, vector <-> '[...]' AS distance FROM vectors ORDER BY distance LIMIT 10
+       * - INSERT INTO vectors (id, vector) VALUES ('x', '[...]')
+       * - DELETE FROM vectors WHERE id = 'x'
+       * @param {string} query
+       * @returns {any}
+       */
+      sql(query) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.rvlite_sql(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Load database from IndexedDB
+       * Returns a Promise<RvLite> with the restored database
+       * @param {RvLiteConfig} config
+       * @returns {Promise<any>}
+       */
+      static load(config) {
+        _assertClass(config, RvLiteConfig);
+        var ptr0 = config.__destroy_into_raw();
+        const ret = wasm.rvlite_load(ptr0);
+        return takeObject(ret);
+      }
+      /**
+       * Save database state to IndexedDB
+       * Returns a Promise that resolves when save is complete
+       * @returns {Promise<any>}
+       */
+      save() {
+        const ret = wasm.rvlite_save(this.__wbg_ptr);
+        return takeObject(ret);
+      }
+      /**
+       * Execute Cypher query
+       *
+       * Supported operations:
+       * - CREATE (n:Label {prop: value})
+       * - MATCH (n:Label) WHERE n.prop = value RETURN n
+       * - CREATE (a)-[r:REL]->(b)
+       * - DELETE n
+       * @param {string} query
+       * @returns {any}
+       */
+      cypher(query) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.rvlite_cypher(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Delete a vector by ID
+       * @param {string} id
+       * @returns {boolean}
+       */
+      delete(id) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.rvlite_delete(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return r0 !== 0;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Insert a vector with optional metadata
+       * Returns the vector ID
+       * @param {Float32Array} vector
+       * @param {any} metadata
+       * @returns {string}
+       */
+      insert(vector, metadata) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passArrayF32ToWasm0(vector, wasm.__wbindgen_export);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.rvlite_insert(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(metadata));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+          var ptr2 = r0;
+          var len2 = r1;
+          if (r3) {
+            ptr2 = 0;
+            len2 = 0;
+            throw takeObject(r2);
+          }
+          deferred3_0 = ptr2;
+          deferred3_1 = len2;
+          return getStringFromWasm0(ptr2, len2);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+          wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+        }
+      }
+      /**
+       * Search for similar vectors
+       * @param {Float32Array} query_vector
+       * @param {number} k
+       * @returns {any}
+       */
+      search(query_vector, k) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passArrayF32ToWasm0(query_vector, wasm.__wbindgen_export);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.rvlite_search(retptr, this.__wbg_ptr, ptr0, len0, k);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Execute SPARQL query
+       *
+       * Supported operations:
+       * - SELECT ?s ?p ?o WHERE { ?s ?p ?o }
+       * - SELECT ?s WHERE { ?s <predicate> ?o }
+       * - ASK { ?s ?p ?o }
+       * @param {string} query
+       * @returns {any}
+       */
+      sparql(query) {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.rvlite_sparql(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Create with default configuration (384 dimensions, cosine similarity)
+       * @returns {RvLite}
+       */
+      static default() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.rvlite_default(retptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return _RvLite.__wrap(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Check if database is empty
+       * @returns {boolean}
+       */
+      is_empty() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.rvlite_is_empty(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return r0 !== 0;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * Check if database is ready
+       * @returns {boolean}
+       */
+      is_ready() {
+        const ret = wasm.rvlite_is_ready(this.__wbg_ptr);
+        return ret !== 0;
+      }
+    };
+    if (Symbol.dispose) RvLite.prototype[Symbol.dispose] = RvLite.prototype.free;
+    RvLiteConfig = class _RvLiteConfig {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_RvLiteConfig.prototype);
+        obj.__wbg_ptr = ptr;
+        RvLiteConfigFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RvLiteConfigFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rvliteconfig_free(ptr, 0);
+      }
+      /**
+       * Get dimensions
+       * @returns {number}
+       */
+      get_dimensions() {
+        const ret = wasm.rvliteconfig_get_dimensions(this.__wbg_ptr);
+        return ret >>> 0;
+      }
+      /**
+       * Get distance metric name
+       * @returns {string}
+       */
+      get_distance_metric() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.rvliteconfig_get_distance_metric(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          deferred1_0 = r0;
+          deferred1_1 = r1;
+          return getStringFromWasm0(r0, r1);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+          wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * Set distance metric (euclidean, cosine, dotproduct, manhattan)
+       * @param {string} metric
+       * @returns {RvLiteConfig}
+       */
+      with_distance_metric(metric) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(metric, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rvliteconfig_with_distance_metric(ptr, ptr0, len0);
+        return _RvLiteConfig.__wrap(ret);
+      }
+      /**
+       * @param {number} dimensions
+       */
+      constructor(dimensions) {
+        const ret = wasm.rvliteconfig_new(dimensions);
+        this.__wbg_ptr = ret >>> 0;
+        RvLiteConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+    };
+    if (Symbol.dispose) RvLiteConfig.prototype[Symbol.dispose] = RvLiteConfig.prototype.free;
+    EXPECTED_RESPONSE_TYPES = /* @__PURE__ */ new Set(["basic", "cors", "default"]);
+    rvlite_default = __wbg_init;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BrowserWriterLease: () => BrowserWriterLease,
+  CypherEngine: () => CypherEngine,
+  RvLite: () => RvLite2,
+  RvLiteConfig: () => RvLiteConfig,
+  SemanticMemory: () => SemanticMemory,
+  bumpMetadataEpoch: () => bumpMetadataEpoch,
+  bumpRvfEpoch: () => bumpRvfEpoch,
+  checkEpochSync: () => checkEpochSync,
+  createAnthropicEmbeddings: () => createAnthropicEmbeddings,
+  createRvLite: () => createRvLite,
+  default: () => index_default,
+  getStorageBackend: () => getStorageBackend,
+  init: () => init,
+  initSync: () => initSync,
+  isRvfAvailable: () => isRvfAvailable,
+  reconcileEpochs: () => reconcileEpochs
+});
+module.exports = __toCommonJS(index_exports);
+init_rvlite();
+var rvfWasmAvailable = null;
+function isRvfAvailable() {
+  if (rvfWasmAvailable !== null) return rvfWasmAvailable;
+  try {
+    require.resolve("@ruvector/rvf-wasm");
+    rvfWasmAvailable = true;
+  } catch {
+    rvfWasmAvailable = false;
+  }
+  return rvfWasmAvailable;
+}
+function getStorageBackend() {
+  if (isRvfAvailable()) return "rvf";
+  if (typeof indexedDB !== "undefined") return "indexeddb";
+  return "memory";
+}
+var RvLite2 = class _RvLite {
+  wasm;
+  config;
+  initialized = false;
+  constructor(config = {}) {
+    this.config = {
+      dimensions: config.dimensions || 384,
+      distanceMetric: config.distanceMetric || "cosine"
+    };
+  }
+  /**
+   * Initialize the WASM module (called automatically on first use)
+   */
+  async init() {
+    if (this.initialized) return;
+    const wasmModule = await Promise.resolve().then(() => (init_rvlite(), rvlite_exports));
+    await wasmModule.default();
+    this.wasm = new wasmModule.RvLite({
+      dimensions: this.config.dimensions,
+      distance_metric: this.config.distanceMetric
+    });
+    this.initialized = true;
+  }
+  async ensureInit() {
+    if (!this.initialized) {
+      await this.init();
+    }
+  }
+  // ============ Vector Operations ============
+  /**
+   * Insert a vector with optional metadata
+   */
+  async insert(vector, metadata) {
+    await this.ensureInit();
+    return this.wasm.insert(vector, metadata || null);
+  }
+  /**
+   * Insert a vector with a specific ID
+   */
+  async insertWithId(id, vector, metadata) {
+    await this.ensureInit();
+    this.wasm.insert_with_id(id, vector, metadata || null);
+  }
+  /**
+   * Search for similar vectors
+   */
+  async search(query, k = 5) {
+    await this.ensureInit();
+    return this.wasm.search(query, k);
+  }
+  /**
+   * Get a vector by ID
+   */
+  async get(id) {
+    await this.ensureInit();
+    return this.wasm.get(id);
+  }
+  /**
+   * Delete a vector by ID
+   */
+  async delete(id) {
+    await this.ensureInit();
+    return this.wasm.delete(id);
+  }
+  /**
+   * Get the number of vectors
+   */
+  async len() {
+    await this.ensureInit();
+    return this.wasm.len();
+  }
+  // ============ SQL Operations ============
+  /**
+   * Execute a SQL query
+   *
+   * Supports vector distance operations:
+   * - distance(col, vector) - Calculate distance
+   * - vec_search(col, vector, k) - Find k nearest
+   */
+  async sql(query) {
+    await this.ensureInit();
+    return this.wasm.sql(query);
+  }
+  // ============ Cypher Operations ============
+  /**
+   * Execute a Cypher graph query
+   *
+   * Supports:
+   * - CREATE (n:Label {props})
+   * - MATCH (n:Label) WHERE ... RETURN n
+   * - CREATE (a)-[:REL]->(b)
+   */
+  async cypher(query) {
+    await this.ensureInit();
+    return this.wasm.cypher(query);
+  }
+  /**
+   * Get Cypher graph statistics
+   */
+  async cypherStats() {
+    await this.ensureInit();
+    return this.wasm.cypher_stats();
+  }
+  // ============ SPARQL Operations ============
+  /**
+   * Execute a SPARQL query
+   *
+   * Supports SELECT, ASK queries over RDF triples
+   */
+  async sparql(query) {
+    await this.ensureInit();
+    return this.wasm.sparql(query);
+  }
+  /**
+   * Add an RDF triple
+   */
+  async addTriple(subject, predicate, object, graph) {
+    await this.ensureInit();
+    this.wasm.add_triple(subject, predicate, object, graph || null);
+  }
+  /**
+   * Get the number of triples
+   */
+  async tripleCount() {
+    await this.ensureInit();
+    return this.wasm.triple_count();
+  }
+  // ============ Persistence ============
+  /**
+   * Export database state to JSON
+   */
+  async exportJson() {
+    await this.ensureInit();
+    return this.wasm.export_json();
+  }
+  /**
+   * Import database state from JSON
+   */
+  async importJson(data) {
+    await this.ensureInit();
+    this.wasm.import_json(data);
+  }
+  /**
+   * Save to IndexedDB (browser only)
+   */
+  async save() {
+    await this.ensureInit();
+    return this.wasm.save();
+  }
+  /**
+   * Load from IndexedDB (browser only)
+   */
+  static async load(config = {}) {
+    const instance = new _RvLite(config);
+    await instance.init();
+    const wasmModule = await Promise.resolve().then(() => (init_rvlite(), rvlite_exports));
+    instance.wasm = await wasmModule.RvLite.load(config);
+    return instance;
+  }
+  /**
+   * Clear IndexedDB storage (browser only)
+   */
+  static async clearStorage() {
+    const wasmModule = await Promise.resolve().then(() => (init_rvlite(), rvlite_exports));
+    return wasmModule.RvLite.clear_storage();
+  }
+  // ============ RVF Persistence ============
+  /**
+   * Factory method: create an RvLite instance backed by an RVF file.
+   *
+   * Opens or creates an RVF file at the given path, initialises the WASM
+   * module, and (when available) uses `@ruvector/rvf-wasm` for vector storage.
+   * Falls back to standard WASM + JSON-based RVF if the optional package is
+   * not installed.
+   *
+   * @param config - Standard RvLiteConfig plus a required `rvfPath`.
+   * @returns A fully-initialised RvLite instance with data loaded from the
+   *          RVF file (if it already exists).
+   */
+  static async createWithRvf(config) {
+    const instance = new _RvLite(config);
+    instance.rvfPath = config.rvfPath;
+    try {
+      const rvfWasm = await import("@ruvector/rvf-wasm");
+      instance.rvfModule = rvfWasm;
+    } catch {
+    }
+    await instance.init();
+    if (typeof globalThis.process !== "undefined") {
+      try {
+        const fs = await import("fs");
+        if (fs.existsSync(config.rvfPath)) {
+          await instance.loadFromRvf(config.rvfPath);
+        }
+      } catch {
+      }
+    }
+    return instance;
+  }
+  /**
+   * Export the current vector state to an RVF file.
+   *
+   * When `@ruvector/rvf-wasm` is available the export uses the native RVF
+   * binary writer.  Otherwise the method falls back to a JSON payload
+   * wrapped with RVF header metadata so the file can be identified as RVF.
+   *
+   * @param filePath - Destination path for the RVF file.
+   */
+  async saveToRvf(filePath) {
+    await this.ensureInit();
+    const jsonState = await this.exportJson();
+    if (this.rvfModule && typeof this.rvfModule.writeRvf === "function") {
+      await this.rvfModule.writeRvf(filePath, jsonState);
+      return;
+    }
+    const rvfEnvelope = {
+      rvf_version: 1,
+      magic: "RVF1",
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      dimensions: this.config.dimensions ?? 384,
+      distance_metric: this.config.distanceMetric ?? "cosine",
+      payload: jsonState
+    };
+    if (typeof globalThis.process !== "undefined") {
+      const fs = await import("fs");
+      const path = await import("path");
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(filePath, JSON.stringify(rvfEnvelope, null, 2), "utf-8");
+    } else {
+      throw new Error(
+        "saveToRvf is only supported in Node.js environments. Use exportJson() for browser-side persistence."
+      );
+    }
+  }
+  /**
+   * Import vector data from an RVF file.
+   *
+   * Parses the RVF format (either native binary via `@ruvector/rvf-wasm` or
+   * the JSON-based fallback envelope) and loads vectors + metadata into the
+   * current instance.
+   *
+   * @param filePath - Source path of the RVF file to import.
+   */
+  async loadFromRvf(filePath) {
+    await this.ensureInit();
+    if (this.rvfModule && typeof this.rvfModule.readRvf === "function") {
+      const data = await this.rvfModule.readRvf(filePath);
+      await this.importJson(data);
+      return;
+    }
+    if (typeof globalThis.process !== "undefined") {
+      const fs = await import("fs");
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`RVF file not found: ${filePath}`);
+      }
+      const raw = fs.readFileSync(filePath, "utf-8");
+      const envelope = JSON.parse(raw);
+      if (envelope.magic !== "RVF1") {
+        throw new Error(
+          `Invalid RVF file: expected magic "RVF1", got "${envelope.magic}"`
+        );
+      }
+      await this.importJson(envelope.payload);
+    } else {
+      throw new Error(
+        "loadFromRvf is only supported in Node.js environments. Use importJson() for browser-side persistence."
+      );
+    }
+  }
+  /** @internal handle to optional @ruvector/rvf-wasm module */
+  rvfModule = null;
+  /** @internal path to the RVF backing file (set by createWithRvf) */
+  rvfPath = null;
+};
+async function createRvLite(config = {}) {
+  const requestedBackend = config.backend || "auto";
+  const actualBackend = requestedBackend === "auto" ? getStorageBackend() : requestedBackend;
+  if (typeof process !== "undefined" && process.env && process.env.RVLITE_DEBUG) {
+    console.log(`[rvlite] storage backend: ${actualBackend} (requested: ${requestedBackend}, rvf available: ${isRvfAvailable()})`);
+  }
+  const db = new RvLite2(config);
+  await db.init();
+  return db;
+}
+function createAnthropicEmbeddings(apiKey) {
+  throw new Error(
+    "Anthropic does not provide embeddings. Use createOpenAIEmbeddings or a custom provider."
+  );
+}
+function sanitizeCypher(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "\\'").replace(/[\x00-\x1f\x7f]/g, "");
+}
+function validateRelationType(rel) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(rel)) {
+    throw new Error(`Invalid relation type: ${rel}`);
+  }
+  return rel;
+}
+var SemanticMemory = class {
+  db;
+  embedder;
+  constructor(db, embedder) {
+    this.db = db;
+    this.embedder = embedder;
+  }
+  /**
+   * Store a memory with semantic embedding
+   */
+  async store(key, content, embedding, metadata) {
+    let vector = embedding;
+    if (!vector && this.embedder) {
+      vector = await this.embedder.embed(content);
+    }
+    if (vector) {
+      await this.db.insertWithId(key, vector, { content, ...metadata });
+    }
+    const safeKey = sanitizeCypher(key);
+    const safeContent = sanitizeCypher(content);
+    await this.db.cypher(
+      `CREATE (m:Memory {key: "${safeKey}", content: "${safeContent}", timestamp: ${Date.now()}})`
+    );
+  }
+  /**
+   * Query memories by semantic similarity
+   */
+  async query(queryText, embedding, k = 5) {
+    let vector = embedding;
+    if (!vector && this.embedder) {
+      vector = await this.embedder.embed(queryText);
+    }
+    if (!vector) {
+      throw new Error("No embedding provided and no embedder configured");
+    }
+    return this.db.search(vector, k);
+  }
+  /**
+   * Add a relationship between memories
+   */
+  async addRelation(fromKey, relation, toKey) {
+    const safeFrom = sanitizeCypher(fromKey);
+    const safeTo = sanitizeCypher(toKey);
+    const safeRel = validateRelationType(relation);
+    await this.db.cypher(
+      `MATCH (a:Memory {key: "${safeFrom}"}), (b:Memory {key: "${safeTo}"}) CREATE (a)-[:${safeRel}]->(b)`
+    );
+  }
+  /**
+   * Find related memories through graph traversal
+   */
+  async findRelated(key, depth = 2) {
+    const safeKey = sanitizeCypher(key);
+    const safeDepth = Math.max(1, Math.min(10, Math.floor(depth)));
+    return this.db.cypher(
+      `MATCH (m:Memory {key: "${safeKey}"})-[*1..${safeDepth}]-(related:Memory) RETURN DISTINCT related`
+    );
+  }
+};
+var BrowserWriterLease = class _BrowserWriterLease {
+  heartbeatInterval = null;
+  storeId = null;
+  static DB_NAME = "_rvlite_locks";
+  static STORE_NAME = "locks";
+  static HEARTBEAT_MS = 1e4;
+  static DEFAULT_STALE_MS = 3e4;
+  // ---- helpers ----
+  static openDb() {
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(_BrowserWriterLease.DB_NAME, 1);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains(_BrowserWriterLease.STORE_NAME)) {
+          db.createObjectStore(_BrowserWriterLease.STORE_NAME, { keyPath: "id" });
+        }
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  static idbPut(db, record) {
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(_BrowserWriterLease.STORE_NAME, "readwrite");
+      const store = tx.objectStore(_BrowserWriterLease.STORE_NAME);
+      const req = store.put(record);
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  }
+  static idbGet(db, key) {
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(_BrowserWriterLease.STORE_NAME, "readonly");
+      const store = tx.objectStore(_BrowserWriterLease.STORE_NAME);
+      const req = store.get(key);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  static idbDelete(db, key) {
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(_BrowserWriterLease.STORE_NAME, "readwrite");
+      const store = tx.objectStore(_BrowserWriterLease.STORE_NAME);
+      const req = store.delete(key);
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  }
+  // ---- public API ----
+  /**
+   * Try to acquire the writer lease for the given store.
+   *
+   * @param storeId  - Unique identifier for the rvlite store being locked.
+   * @param timeout  - Maximum time in ms to wait for the lease (default 5000).
+   * @returns `true` if the lease was acquired, `false` on timeout.
+   */
+  async acquire(storeId, timeout = 5e3) {
+    if (typeof indexedDB === "undefined") {
+      throw new Error("BrowserWriterLease requires IndexedDB");
+    }
+    const deadline = Date.now() + timeout;
+    const db = await _BrowserWriterLease.openDb();
+    while (Date.now() < deadline) {
+      const existing = await _BrowserWriterLease.idbGet(db, storeId);
+      if (!existing || await _BrowserWriterLease.isStale(storeId)) {
+        await _BrowserWriterLease.idbPut(db, {
+          id: storeId,
+          holder: this.holderId(),
+          ts: Date.now()
+        });
+        const confirm = await _BrowserWriterLease.idbGet(db, storeId);
+        if (confirm && confirm.holder === this.holderId()) {
+          this.storeId = storeId;
+          this.startHeartbeat(db);
+          this.registerUnloadHandler();
+          db.close();
+          return true;
+        }
+      }
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    db.close();
+    return false;
+  }
+  /**
+   * Release the currently held lease.
+   */
+  async release() {
+    this.stopHeartbeat();
+    if (this.storeId === null) return;
+    try {
+      const db = await _BrowserWriterLease.openDb();
+      await _BrowserWriterLease.idbDelete(db, this.storeId);
+      db.close();
+    } catch {
+    }
+    this.storeId = null;
+  }
+  /**
+   * Check whether the lease for `storeId` is stale (the holder has stopped
+   * sending heartbeats).
+   *
+   * @param storeId     - Store identifier.
+   * @param thresholdMs - Staleness threshold (default 30 000 ms).
+   */
+  static async isStale(storeId, thresholdMs = _BrowserWriterLease.DEFAULT_STALE_MS) {
+    if (typeof indexedDB === "undefined") return true;
+    const db = await _BrowserWriterLease.openDb();
+    const record = await _BrowserWriterLease.idbGet(db, storeId);
+    db.close();
+    if (!record) return true;
+    return Date.now() - record.ts > thresholdMs;
+  }
+  // ---- private helpers ----
+  _holderId = null;
+  holderId() {
+    if (!this._holderId) {
+      this._holderId = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    }
+    return this._holderId;
+  }
+  startHeartbeat(db) {
+    this.stopHeartbeat();
+    const storeId = this.storeId;
+    const holder = this.holderId();
+    const beat = async () => {
+      try {
+        const freshDb = await _BrowserWriterLease.openDb();
+        await _BrowserWriterLease.idbPut(freshDb, {
+          id: storeId,
+          holder,
+          ts: Date.now()
+        });
+        freshDb.close();
+      } catch {
+      }
+    };
+    this.heartbeatInterval = setInterval(
+      beat,
+      _BrowserWriterLease.HEARTBEAT_MS
+    );
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval !== null) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  registerUnloadHandler() {
+    if (typeof globalThis.addEventListener === "function") {
+      const handler = () => {
+        this.stopHeartbeat();
+      };
+      globalThis.addEventListener("beforeunload", handler, { once: true });
+    }
+  }
+};
+async function checkEpochSync(db) {
+  const rvfEntry = await db.get("_rvlite_rvf_epoch");
+  const metaEntry = await db.get("_rvlite_metadata_epoch");
+  const rvfEpoch = rvfEntry?.metadata?.epoch ?? 0;
+  const metadataEpoch = metaEntry?.metadata?.epoch ?? 0;
+  let status;
+  if (rvfEpoch === metadataEpoch) {
+    status = "synchronized";
+  } else if (rvfEpoch > metadataEpoch) {
+    status = "rvf_ahead";
+  } else {
+    status = "metadata_ahead";
+  }
+  return { rvfEpoch, metadataEpoch, status };
+}
+async function reconcileEpochs(db, state) {
+  if (state.status === "synchronized") return;
+  const targetEpoch = Math.max(state.rvfEpoch, state.metadataEpoch);
+  const dummyVector = [0];
+  try {
+    await db.delete("_rvlite_rvf_epoch");
+  } catch {
+  }
+  try {
+    await db.delete("_rvlite_metadata_epoch");
+  } catch {
+  }
+  await db.insertWithId("_rvlite_rvf_epoch", dummyVector, { epoch: targetEpoch });
+  await db.insertWithId("_rvlite_metadata_epoch", dummyVector, { epoch: targetEpoch });
+}
+async function bumpRvfEpoch(db) {
+  const current = await checkEpochSync(db);
+  const next = current.rvfEpoch + 1;
+  const dummyVector = [0];
+  try {
+    await db.delete("_rvlite_rvf_epoch");
+  } catch {
+  }
+  await db.insertWithId("_rvlite_rvf_epoch", dummyVector, { epoch: next });
+  return next;
+}
+async function bumpMetadataEpoch(db) {
+  const current = await checkEpochSync(db);
+  const next = current.metadataEpoch + 1;
+  const dummyVector = [0];
+  try {
+    await db.delete("_rvlite_metadata_epoch");
+  } catch {
+  }
+  await db.insertWithId("_rvlite_metadata_epoch", dummyVector, { epoch: next });
+  return next;
+}
+var index_default = RvLite2;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserWriterLease,
+  CypherEngine,
+  RvLite,
+  RvLiteConfig,
+  SemanticMemory,
+  bumpMetadataEpoch,
+  bumpRvfEpoch,
+  checkEpochSync,
+  createAnthropicEmbeddings,
+  createRvLite,
+  getStorageBackend,
+  init,
+  initSync,
+  isRvfAvailable,
+  reconcileEpochs
+});