@foretag/tanstack-db-surrealdb 0.5.8 → 0.6.0

package/dist/index.js

@@ -6,12 +6,20 @@ var surrealdb = require('surrealdb');
 var db = require('@tanstack/db');
 
 // src/index.ts
-var recordIdInternPool = /* @__PURE__ */ new Map();
-var internRecordId = (canonical) => {
-  const cached = recordIdInternPool.get(canonical);
+var recordIdIdentityPool = /* @__PURE__ */ new Map();
+var nativeRecordIdPool = /* @__PURE__ */ new Map();
+var internRecordIdIdentity = (canonical, preferred) => {
+  const cached = recordIdIdentityPool.get(canonical);
+  if (cached !== void 0) return cached;
+  const created = preferred ?? canonicalToNativeRecordId(canonical);
+  recordIdIdentityPool.set(canonical, created);
+  return created;
+};
+var getNativeRecordId = (canonical) => {
+  const cached = nativeRecordIdPool.get(canonical);
   if (cached) return cached;
   const created = canonicalToNativeRecordId(canonical);
-  recordIdInternPool.set(canonical, created);
+  nativeRecordIdPool.set(canonical, created);
   return created;
 };
 var canonicalToNativeRecordId = (canonical) => {
@@ -56,6 +64,26 @@ var isRecordIdString = (value) => {
   return idx > 0 && idx < value.length - 1;
 };
 var looksLikeTableName = (value) => /^[A-Za-z_][A-Za-z0-9_-]*$/.test(value);
+var getCtorName = (value) => {
+  if (!value || typeof value !== "object") return void 0;
+  const ctor = value.constructor;
+  return typeof ctor?.name === "string" ? ctor.name : void 0;
+};
+var isCrossRuntimeRecordIdObject = (value) => {
+  if (!value || typeof value !== "object" || value instanceof surrealdb.RecordId) {
+    return false;
+  }
+  const obj = value;
+  if (typeof obj.toString !== "function") return false;
+  if (!("table" in obj) || !("id" in obj)) return false;
+  const ctorName = getCtorName(value);
+  if (!ctorName || !/^RecordId\d*$/.test(ctorName)) return false;
+  const tableValue = obj.table;
+  const table = typeof tableValue === "string" ? tableValue : tableValue != null ? String(tableValue) : "";
+  const idValue = obj.id;
+  const idIsPrimitive = typeof idValue === "string" || typeof idValue === "number" || typeof idValue === "bigint";
+  return idIsPrimitive && looksLikeTableName(stripOuterQuotes(table).trim());
+};
 var toCanonicalRecordIdString = (value) => {
   const normalized = toRecordIdString(value);
   if (!isRecordIdString(normalized)) return void 0;
@@ -72,6 +100,16 @@ var unwrapIdWrapper = (value) => {
   if (keys.length !== 1 || keys[0] !== "id") return void 0;
   return obj.id;
 };
+var asCanonicalRecordIdFromCrossRuntimeObject = (value) => {
+  if (!isCrossRuntimeRecordIdObject(value)) return void 0;
+  const obj = value;
+  const tableRaw = typeof obj.table === "string" ? obj.table : String(obj.table);
+  const table = stripOuterQuotes(tableRaw).trim();
+  const id = String(obj.id);
+  const fromFields = table && id && looksLikeTableName(table) ? `${table}:${id}` : void 0;
+  if (fromFields) return toCanonicalRecordIdString(fromFields);
+  return toCanonicalRecordIdString(String(obj.toString()));
+};
 var asCanonicalRecordIdString = (value) => {
   if (typeof value === "string") {
     return toCanonicalRecordIdString(value);
@@ -79,6 +117,8 @@ var asCanonicalRecordIdString = (value) => {
   if (value instanceof surrealdb.RecordId) {
     return toCanonicalRecordIdString(value.toString());
   }
+  const crossRuntimeCanonical = asCanonicalRecordIdFromCrossRuntimeObject(value);
+  if (crossRuntimeCanonical) return crossRuntimeCanonical;
   const wrappedId = unwrapIdWrapper(value);
   if (wrappedId === void 0 || wrappedId === value) return void 0;
   return asCanonicalRecordIdString(wrappedId);
@@ -87,52 +127,36 @@ var toNativeRecordIdLikeValue = (value) => {
   if (value instanceof surrealdb.RecordId) {
     const canonical2 = asCanonicalRecordIdString(value);
     if (!canonical2) return value;
-    return internRecordId(canonical2);
+    return getNativeRecordId(canonical2);
   }
   const canonical = asCanonicalRecordIdString(value);
   if (!canonical) return value;
-  return internRecordId(canonical);
+  return getNativeRecordId(canonical);
 };
-var preferRecordIdLikeIdentity = (value) => {
-  const canonical = asCanonicalRecordIdString(value);
-  if (!canonical) return normalizeRecordIdLikeValue(value);
+var normalizeRecordIdLikeValue = (value) => {
   if (value instanceof surrealdb.RecordId) {
-    recordIdInternPool.set(canonical, value);
-    return value;
-  }
-  const wrappedId = unwrapIdWrapper(value);
-  if (wrappedId instanceof surrealdb.RecordId) {
-    recordIdInternPool.set(canonical, wrappedId);
-    return wrappedId;
-  }
-  return internRecordId(canonical);
-};
-var preferRecordIdLikeIdentityDeep = (value) => {
-  const preferred = preferRecordIdLikeIdentity(value);
-  if (Array.isArray(preferred)) {
-    return preferred.map(
-      (item) => preferRecordIdLikeIdentityDeep(item)
-    );
+    const canonical2 = asCanonicalRecordIdString(value);
+    if (!canonical2) return value;
+    return internRecordIdIdentity(canonical2, value);
   }
-  if (isPlainObject(preferred)) {
-    const out = {};
-    for (const [k, v] of Object.entries(preferred)) {
-      out[k] = preferRecordIdLikeIdentityDeep(v);
+  if (typeof value === "object" && value !== null) {
+    const canonical2 = asCanonicalRecordIdString(value);
+    if (!canonical2) return value;
+    if (isCrossRuntimeRecordIdObject(value)) {
+      return internRecordIdIdentity(canonical2, value);
     }
-    return out;
+    const wrappedId = unwrapIdWrapper(value);
+    if (wrappedId instanceof surrealdb.RecordId || isCrossRuntimeRecordIdObject(wrappedId)) {
+      return internRecordIdIdentity(canonical2, wrappedId);
+    }
+    return internRecordIdIdentity(canonical2);
   }
-  return preferred;
-};
-var normalizeRecordIdLikeValue = (value) => {
-  if (value instanceof surrealdb.RecordId) return toNativeRecordIdLikeValue(value);
-  if (typeof value === "object" && value !== null)
-    return toNativeRecordIdLikeValue(value);
   if (typeof value !== "string") return value;
   const trimmed = value.trim();
   const unquoted = stripOuterQuotes(trimmed);
   const canonical = toCanonicalRecordIdString(unquoted) ?? (unquoted === trimmed ? void 0 : toCanonicalRecordIdString(trimmed));
   if (canonical) {
-    return internRecordId(canonical);
+    return internRecordIdIdentity(canonical);
   }
   return value;
 };
@@ -169,125 +193,65 @@ var toRecordId = (tableName, id) => {
   const key = normalized.startsWith(prefixed) ? normalized.slice(prefixed.length) : normalized;
   return new surrealdb.RecordId(tableName, key);
 };
-var parseRecordIdLike = (value) => {
-  const normalized = normalizeRecordIdLikeValue(value);
-  if (normalized instanceof surrealdb.RecordId) {
-    return {
-      table: String(normalized.table),
-      id: String(normalized.id)
-    };
-  }
-  const str = toRecordIdString(String(normalized));
-  const idx = str.indexOf(":");
-  if (idx <= 0 || idx >= str.length - 1) {
-    throw new Error(
-      `Expected a record id in 'table:id' format, received '${String(value)}'.`
-    );
-  }
+
+// src/crdt.ts
+var toRecord = (value) => typeof value === "object" && value !== null ? value : {};
+var materializeLoroJson = (doc, id) => {
+  const root = toRecord(doc.getMap("root").toJSON());
   return {
-    table: str.slice(0, idx),
-    id: str.slice(idx + 1)
+    id,
+    ...root
   };
 };
-var eqRecordId = (field, value) => {
-  const parsed = parseRecordIdLike(value);
-  const fieldRef = field;
-  const canonical = `${parsed.table}:${parsed.id}`;
-  return db.or(
-    db.eq(fieldRef, canonical),
-    db.eq(fieldRef.id, parsed.id)
-  );
-};
-var serializeValue = (value) => {
-  const canonicalRecordId = asCanonicalRecordIdString(value);
-  if (canonicalRecordId) {
-    return {
-      __type: "recordid",
-      value: canonicalRecordId
-    };
+var applyLoroJsonChange = (doc, change) => {
+  const root = doc.getMap("root");
+  if (change.type === "delete") {
+    root.set("deleted", true);
+    return;
   }
-  const normalized = normalizeRecordIdLikeValue(value);
-  if (normalized instanceof surrealdb.RecordId) {
-    return {
-      __type: "recordid",
-      value: toRecordIdString(normalized)
-    };
+  const value = toRecord(change.value);
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (key === "id") continue;
+    root.set(key, fieldValue);
   }
-  if (normalized === void 0) {
-    return { __type: "undefined" };
+};
+var materializeLoroRichtext = (doc, id) => {
+  const metadata = toRecord(doc.getMap("root").toJSON());
+  const content = doc.getText("content").toString();
+  return {
+    id,
+    content,
+    ...metadata
+  };
+};
+var applyLoroRichtextChange = (doc, change) => {
+  const text = doc.getText("content");
+  const metadata = doc.getMap("root");
+  if (change.type === "delete") {
+    metadata.set("deleted", true);
+    return;
   }
-  if (typeof normalized === "number") {
-    if (Number.isNaN(normalized)) return { __type: "nan" };
-    if (normalized === Number.POSITIVE_INFINITY) {
-      return { __type: "infinity", sign: 1 };
-    }
-    if (normalized === Number.NEGATIVE_INFINITY) {
-      return { __type: "infinity", sign: -1 };
+  const value = toRecord(change.value);
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (key === "id") continue;
+    if (key === "content") {
+      if (typeof fieldValue === "string") text.update(fieldValue);
+      continue;
     }
+    metadata.set(key, fieldValue);
   }
-  if (normalized === null || typeof normalized === "string" || typeof normalized === "number" || typeof normalized === "boolean") {
-    return normalized;
-  }
-  if (normalized instanceof Date) {
-    return { __type: "date", value: normalized.toJSON() };
-  }
-  if (Array.isArray(normalized)) {
-    return normalized.map((item) => serializeValue(item));
-  }
-  if (typeof normalized === "object") {
-    const entries = Object.entries(
-      normalized
-    ).sort(([a], [b]) => a.localeCompare(b));
-    return Object.fromEntries(
-      entries.map(([key, item]) => [key, serializeValue(item)])
-    );
-  }
-  return normalized;
 };
-var serializeExpression = (expr) => {
-  if (!expr) return null;
-  switch (expr.type) {
-    case "val":
-      return {
-        type: "val",
-        value: serializeValue(expr.value)
-      };
-    case "ref":
-      return {
-        type: "ref",
-        path: [...expr.path]
-      };
-    case "func":
-      return {
-        type: "func",
-        name: expr.name,
-        args: expr.args.map(
-          (arg) => serializeExpression(arg)
-        )
-      };
-    default:
-      return null;
+var createLoroProfile = (profile) => {
+  if (profile === "richtext") {
+    return {
+      materialize: materializeLoroRichtext,
+      applyLocalChange: applyLoroRichtextChange
+    };
   }
-};
-var serializeSurrealSubsetOptions = (options) => {
-  if (!options) return void 0;
-  const out = {};
-  if (options.where) out.where = serializeExpression(options.where);
-  if (options.orderBy?.length) {
-    out.orderBy = options.orderBy.map((clause) => ({
-      expression: serializeExpression(
-        clause.expression
-      ),
-      direction: clause.compareOptions.direction,
-      nulls: clause.compareOptions.nulls,
-      stringSort: clause.compareOptions.stringSort,
-      locale: clause.compareOptions.locale,
-      localeOptions: clause.compareOptions.localeOptions
-    }));
-  }
-  if (options.limit !== void 0) out.limit = options.limit;
-  if (options.offset !== void 0) out.offset = options.offset;
-  return Object.keys(out).length ? JSON.stringify(out) : void 0;
+  return {
+    materialize: materializeLoroJson,
+    applyLocalChange: applyLoroJsonChange
+  };
 };
 var IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var firstRow = (res) => {
@@ -350,7 +314,7 @@ var joinLogical = (op, args) => {
     sql: parts.map((part) => `(${part})`).join(` ${op} `)
   };
 };
-var buildSubsetQuery = (table, useLoro, subset) => {
+var buildSubsetQuery = (table, subset) => {
   let paramIdx = 0;
   const params = { table: table.name };
   const nextParam = (value) => {
@@ -371,7 +335,7 @@ var buildSubsetQuery = (table, useLoro, subset) => {
     }
     if (isReferencePathCandidate(value)) {
       throw new Error(
-        "Got a field reference on the right side of a where comparison. Pass a concrete value (string/RecordId), not a reactive proxy/path."
+        "Got a field reference on the right side of a where comparison. Pass a concrete value."
       );
     }
     return {
@@ -439,7 +403,6 @@ var buildSubsetQuery = (table, useLoro, subset) => {
     const cursorWhere = whereSqlFrom(subset.cursor.whereFrom);
     if (cursorWhere) whereParts.push(cursorWhere);
   }
-  if (useLoro) whereParts.push("sync_deleted = false");
   const whereSql = whereParts.length ? ` WHERE ${whereParts.map((part) => `(${part})`).join(" AND ")}` : "";
   const order = db.parseOrderByExpression(subset?.orderBy);
   const orderSql = order.length ? ` ORDER BY ${order.map(
@@ -454,14 +417,14 @@ var buildSubsetQuery = (table, useLoro, subset) => {
     params
   };
 };
-function manageTable(db, useLoro, config) {
+function manageTable(db, config) {
   const { name } = config;
   const table = new surrealdb.Table(name);
   const listAll = async () => {
     return loadSubset();
   };
   const loadSubset = async (subset) => {
-    const { sql, params } = buildSubsetQuery(config, useLoro, subset);
+    const { sql, params } = buildSubsetQuery(config, subset);
     const [res] = await db.query(sql, params);
     return res ?? [];
   };
@@ -478,29 +441,11 @@ function manageTable(db, useLoro, config) {
   };
   const update = async (id, data) => {
     const { id: _ignoredId, ...rest } = data;
-    if (!useLoro) {
-      await db.update(id).merge(rest);
-      return;
-    }
-    await db.update(id).merge({
-      ...rest,
-      sync_deleted: false,
-      updated_at: Date.now()
-    });
+    await db.update(id).merge(rest);
   };
   const remove = async (id) => {
     await db.delete(id);
   };
-  const softDelete = async (id) => {
-    if (!useLoro) {
-      await db.delete(id);
-      return;
-    }
-    await db.upsert(id).merge({
-      sync_deleted: true,
-      updated_at: Date.now()
-    });
-  };
   const subscribe = (cb) => {
     let killed = false;
     let live;
@@ -509,8 +454,7 @@ function manageTable(db, useLoro, config) {
       if (action === "KILLED") return;
       if (action === "CREATE") cb({ type: "insert", row: value });
       else if (action === "UPDATE") cb({ type: "update", row: value });
-      else if (action === "DELETE")
-        cb({ type: "delete", row: { id: value.id } });
+      else if (action === "DELETE") cb({ type: "delete", row: { id: value.id } });
     };
     const start = async () => {
       if (!db.isFeatureSupported(surrealdb.Features.LiveQueries)) return;
@@ -530,93 +474,205 @@ function manageTable(db, useLoro, config) {
     create,
     update,
     remove,
-    softDelete,
+    softDelete: remove,
     subscribe
   };
 }
 
-// src/index.ts
-var TEMP_ID_PREFIX = "__temp__";
-var NOOP = () => {
-};
-var SUBSCRIBE_PATCHED = Symbol("surrealdbSubscribePatched");
-var patchSubscribeChangesForRecordIds = (collection) => {
-  if (!collection || typeof collection !== "object") return;
-  const target = collection;
-  if (target[SUBSCRIBE_PATCHED]) return;
-  if (typeof target.subscribeChanges !== "function") return;
-  const original = target.subscribeChanges.bind(target);
-  target.subscribeChanges = (callback, options) => {
-    const nextOptions = options ? { ...options } : options;
-    if (nextOptions?.whereExpression)
-      normalizeExpressionLiteralsInPlace(nextOptions.whereExpression);
-    if (typeof nextOptions?.where === "function") {
-      const originalWhere = nextOptions.where;
-      nextOptions.where = (row) => {
-        const expr = originalWhere(row);
-        normalizeExpressionLiteralsWithExistingIdentityInPlace(expr);
-        return expr;
-      };
-    }
-    return original(callback, nextOptions);
-  };
-  target[SUBSCRIBE_PATCHED] = true;
+// src/util.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var hasBuffer = typeof Buffer !== "undefined";
+function toBytes(value) {
+  if (typeof value === "string") return encoder.encode(value);
+  return encoder.encode(JSON.stringify(value));
+}
+function fromBytes(bytes, deserialize = false) {
+  if (deserialize) return JSON.parse(decoder.decode(bytes));
+  return decoder.decode(bytes);
+}
+function toBase64(bytes) {
+  if (hasBuffer) return Buffer.from(bytes).toString("base64");
+  return btoa(String.fromCharCode(...bytes));
+}
+function fromBase64(base64) {
+  if (hasBuffer) return new Uint8Array(Buffer.from(base64, "base64"));
+  const bin = atob(base64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) {
+    out[i] = bin.charCodeAt(i);
+  }
+  return out;
+}
+
+// src/encryption/index.ts
+var DEFAULT_ALG = "AES-256-GCM";
+var DEFAULT_KID = "default";
+var DEFAULT_VERSION = 1;
+var resolveCrypto = () => {
+  if (typeof globalThis.crypto !== "undefined") return globalThis.crypto;
+  throw new Error("Web Crypto API is not available in this runtime.");
 };
-var normalizeExpressionLiteralsInPlace = (expr) => {
-  if (!expr || typeof expr !== "object") return;
-  const node = expr;
-  if (node.type === "val") {
-    node.value = preferRecordIdLikeIdentityDeep(node.value);
-    return;
+var toCryptoBytes = (value) => new Uint8Array(value);
+var WebCryptoAESGCM = class _WebCryptoAESGCM {
+  alg;
+  version;
+  kid;
+  resolveKey;
+  constructor(key, options = {}) {
+    this.alg = options.alg ?? DEFAULT_ALG;
+    this.version = options.version ?? DEFAULT_VERSION;
+    this.kid = options.kid ?? DEFAULT_KID;
+    this.resolveKey = options.resolveKey ?? ((incomingKid) => {
+      if (incomingKid !== this.kid) {
+        throw new Error(`No key configured for kid '${incomingKid}'.`);
+      }
+      return key;
+    });
   }
-  if (node.type === "func" && Array.isArray(node.args)) {
-    for (const arg of node.args) normalizeExpressionLiteralsInPlace(arg);
+  static async fromRawKey(rawKey, options = {}) {
+    const key = await resolveCrypto().subtle.importKey(
+      "raw",
+      toCryptoBytes(rawKey),
+      "AES-GCM",
+      false,
+      ["encrypt", "decrypt"]
+    );
+    return new _WebCryptoAESGCM(key, options);
   }
-};
-var normalizeExpressionLiteralsWithExistingIdentityInPlace = (expr) => {
-  if (!expr || typeof expr !== "object") return;
-  const node = expr;
-  if (node.type === "val") {
-    node.value = normalizeRecordIdLikeValueDeep(node.value);
-    return;
+  async keyFor(kid) {
+    return await this.resolveKey(kid);
   }
-  if (node.type === "func" && Array.isArray(node.args)) {
-    for (const arg of node.args)
-      normalizeExpressionLiteralsWithExistingIdentityInPlace(arg);
+  async encrypt(input) {
+    const crypto = resolveCrypto();
+    const alg = input.alg ?? this.alg;
+    const kid = input.kid ?? this.kid;
+    const v = input.v ?? this.version;
+    const nonce = crypto.getRandomValues(new Uint8Array(12));
+    const key = await this.keyFor(kid);
+    const ct = new Uint8Array(
+      await crypto.subtle.encrypt(
+        {
+          name: "AES-GCM",
+          iv: nonce,
+          additionalData: input.aad ? toCryptoBytes(input.aad) : void 0
+        },
+        key,
+        toCryptoBytes(input.plaintext)
+      )
+    );
+    return {
+      v,
+      alg,
+      kid,
+      n: toBase64(nonce),
+      ct: toBase64(ct)
+    };
   }
+  async decrypt({ envelope, aad }) {
+    if (envelope.alg !== this.alg) {
+      throw new Error(
+        `Unsupported envelope algorithm '${envelope.alg}'. Expected '${this.alg}'.`
+      );
+    }
+    const key = await this.keyFor(envelope.kid);
+    const crypto = resolveCrypto();
+    const plaintext = await crypto.subtle.decrypt(
+      {
+        name: "AES-GCM",
+        iv: toCryptoBytes(fromBase64(envelope.n)),
+        additionalData: aad ? toCryptoBytes(aad) : void 0
+      },
+      key,
+      toCryptoBytes(fromBase64(envelope.ct))
+    );
+    return new Uint8Array(plaintext);
+  }
+};
+
+// src/index.ts
+var TEMP_ID_PREFIX = "__temp__";
+var ENVELOPE_FIELDS = [
+  "version",
+  "algorithm",
+  "key_id",
+  "nonce",
+  "ciphertext"
+];
+var NOOP = () => {
+};
+var isTableObject = (value) => typeof value === "object" && value !== null && "name" in value && typeof value.name === "string";
+var toTableOptions = (table) => {
+  if (typeof table === "string") return { name: table };
+  if (table instanceof surrealdb.Table) return { name: table.name };
+  if (isTableObject(table)) return table;
+  throw new Error("Expected table as string, Table, or { name }.");
 };
-var normalizeSubsetLiteralsInPlace = (subset) => {
-  if (!subset) return;
-  normalizeExpressionLiteralsInPlace(subset.where);
-  normalizeExpressionLiteralsInPlace(subset.cursor?.whereFrom);
-  normalizeExpressionLiteralsInPlace(subset.cursor?.whereCurrent);
+var toTableResource = (table) => {
+  const normalized = toTableOptions(table);
+  return new surrealdb.Table(normalized.name);
+};
+var tableNameOf = (table) => toTableOptions(table).name;
+var getWriteUtils = (utils) => typeof utils === "object" && utils !== null ? utils : {};
+var firstRow2 = (result) => {
+  if (!result) return void 0;
+  if (Array.isArray(result)) return result[0];
+  return result;
 };
+var omitUndefined = (obj) => Object.fromEntries(
+  Object.entries(obj).filter(([, value]) => value !== void 0)
+);
 var createTempRecordId = (tableName) => {
   const suffix = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
   return new surrealdb.RecordId(tableName, `${TEMP_ID_PREFIX}${suffix}`);
 };
 var isTempId = (id, tableName) => {
-  if (id instanceof surrealdb.RecordId) {
-    const recordKey = id.id;
-    return typeof recordKey === "string" && recordKey.startsWith(TEMP_ID_PREFIX);
-  }
-  const raw = toRecordIdString(id);
-  const key = raw.startsWith(`${tableName}:`) ? raw.slice(tableName.length + 1) : raw;
+  const normalized = toRecordIdString(id);
+  const key = normalized.startsWith(`${tableName}:`) ? normalized.slice(tableName.length + 1) : normalized;
   return key.startsWith(TEMP_ID_PREFIX);
 };
-function toCleanup(res) {
-  if (!res) return NOOP;
-  if (typeof res === "function") return res;
-  const cleanup = res.cleanup ?? res.unsubscribe ?? res.dispose;
-  return typeof cleanup === "function" ? cleanup : NOOP;
-}
-function hasLoadSubset(res) {
-  return typeof res === "object" && res !== null && "loadSubset" in res;
+var toEnvelope = (value) => {
+  const version = value.version;
+  const algorithm = value.algorithm;
+  const keyId = value.key_id;
+  const nonce = value.nonce;
+  const ciphertext = value.ciphertext;
+  if (typeof version !== "number" || typeof algorithm !== "string" || typeof keyId !== "string" || typeof nonce !== "string" || typeof ciphertext !== "string") {
+    return null;
+  }
+  return {
+    v: version,
+    alg: algorithm,
+    kid: keyId,
+    n: nonce,
+    ct: ciphertext
+  };
+};
+var toStoredEnvelope = (envelope) => ({
+  version: envelope.v,
+  algorithm: envelope.alg,
+  key_id: envelope.kid,
+  nonce: envelope.n,
+  ciphertext: envelope.ct
+});
+var stripEnvelopeFields = (value) => {
+  const copy = { ...value };
+  for (const key of ENVELOPE_FIELDS) delete copy[key];
+  return copy;
+};
+var toRecordArray = (rows) => {
+  if (!rows) return [];
+  return Array.isArray(rows) ? rows : [rows];
+};
+async function queryRows(db, sql, bindings) {
+  const result = await db.query(sql, bindings ?? {});
+  if (Array.isArray(result)) {
+    const first = result[0];
+    if (Array.isArray(first)) return first;
+    return [];
+  }
+  return [];
 }
-var getWriteUtils = (utils) => typeof utils === "object" && utils !== null ? utils : {};
-var omitUndefined = (obj) => Object.fromEntries(
-  Object.entries(obj).filter(([, value]) => value !== void 0)
-);
 function createInsertSchema(tableName) {
   return {
     "~standard": {
@@ -631,224 +687,637 @@ function createInsertSchema(tableName) {
         const data = normalizeRecordIdLikeFields({
           ...value
         });
-        if (!data.id)
-          data.id = createTempRecordId(tableName);
+        if (!data.id) data.id = createTempRecordId(tableName);
         return { value: data };
       },
       types: void 0
     }
   };
 }
-function surrealCollectionOptions({
-  id,
-  useLoro = false,
-  onError,
-  db,
-  queryClient,
-  queryKey,
-  syncMode = "eager",
-  ...config
-}) {
-  let loro;
-  if (useLoro) loro = { doc: new loroCrdt.LoroDoc(), key: id };
-  const resolvedQueryKey = syncMode === "on-demand" ? (opts = {}) => {
-    normalizeSubsetLiteralsInPlace(opts);
-    const serialized = serializeSurrealSubsetOptions(opts);
-    return serialized ? [...queryKey, serialized] : [...queryKey];
-  } : queryKey;
-  const table = manageTable(db, useLoro, config.table);
-  const keyOf = (rid) => toRecordIdString(rid);
-  const getKey = (row) => keyOf(row.id);
-  const normalizeMutationId = (rid) => toRecordId(config.table.name, rid);
-  const withRecordId = (row) => {
+function defaultAad(ctx) {
+  if (ctx.kind === "base") return toBytes(`${ctx.table}:${ctx.id}`);
+  const base = ctx.baseTable ?? ctx.table;
+  return toBytes(`${ctx.table}:${base}:${ctx.id}`);
+}
+var syncModeFrom = (syncMode) => syncMode ?? "eager";
+var subsetCacheKey = (subset) => JSON.stringify(subset, (_key, value) => {
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof surrealdb.RecordId) return toRecordIdString(value);
+  if (typeof value === "function") return void 0;
+  if (value && typeof value === "object" && "table" in value && "id" in value) {
+    try {
+      return toRecordIdString(String(value));
+    } catch {
+      return value;
+    }
+  }
+  return value;
+});
+function modernSurrealCollectionOptions(config) {
+  const {
+    db,
+    table,
+    queryClient,
+    queryKey,
+    onError,
+    e2ee,
+    crdt,
+    syncMode: inputSyncMode
+  } = config;
+  if (!queryClient || !queryKey) {
+    throw new Error("queryClient and queryKey are required.");
+  }
+  const syncMode = syncModeFrom(inputSyncMode);
+  const isOnDemandLike = syncMode === "on-demand" || syncMode === "progressive";
+  const isStrictOnDemand = syncMode === "on-demand";
+  const queryDrivenSyncMode = isOnDemandLike ? "on-demand" : "eager";
+  const tableOptions = toTableOptions(table);
+  const tableName = tableOptions.name;
+  const tableResource = toTableResource(table);
+  const subsetIds = /* @__PURE__ */ new Map();
+  const activeOnDemandIds = /* @__PURE__ */ new Set();
+  const e2eeEnabled = e2ee?.enabled === true;
+  const crdtEnabled = crdt?.enabled === true;
+  const defaultCrdtProfile = crdtEnabled ? createLoroProfile(crdt.profile) : void 0;
+  const materializeCrdt = crdt?.materialize ?? defaultCrdtProfile?.materialize;
+  const applyCrdtLocalChange = crdt?.applyLocalChange ?? defaultCrdtProfile?.applyLocalChange;
+  if (crdtEnabled && (!materializeCrdt || !applyCrdtLocalChange)) {
+    throw new Error(
+      "CRDT profile adapter is missing materialize/applyLocalChange handlers."
+    );
+  }
+  const tableAccess = manageTable(db, tableOptions);
+  const docs = /* @__PURE__ */ new Map();
+  const aadFor = (ctx) => (e2ee?.aad ?? defaultAad)(ctx);
+  const getKey = (row) => toRecordIdString(row.id);
+  const normalizeMutationId = (id) => toRecordId(tableName, id);
+  const normalizeRow = (row) => {
     const normalized = normalizeRecordIdLikeValueDeep(row);
     return {
       ...normalized,
       id: normalizeMutationId(normalized.id)
     };
   };
-  const toLoroStoredRow = (row) => ({ ...row, id: keyOf(row.id) });
-  const loroKey = loro?.key ?? id ?? "surreal";
-  const loroMap = useLoro ? loro?.doc?.getMap?.(loroKey) ?? null : null;
-  const commitLoro = () => {
-    loro?.doc?.commit?.();
+  const decodeBaseRow = async (row) => {
+    if (!e2eeEnabled) {
+      return normalizeRow(row);
+    }
+    const envelope = toEnvelope(row);
+    if (!envelope) return normalizeRow(row);
+    const id = toRecordKeyString(row.id);
+    const bytes = await e2ee.crypto.decrypt({
+      envelope,
+      aad: aadFor({ table: tableName, id, kind: "base" })
+    });
+    const payload = fromBytes(bytes, true);
+    const merged = {
+      ...stripEnvelopeFields(row),
+      ...payload,
+      id: normalizeMutationId(row.id)
+    };
+    return normalizeRow(merged);
+  };
+  const encodeBaseRow = async (row, id) => {
+    if (!e2eeEnabled) return row;
+    const envelope = await e2ee.crypto.encrypt({
+      plaintext: toBytes(row),
+      aad: aadFor({ table: tableName, id, kind: "base" })
+    });
+    return toStoredEnvelope(envelope);
+  };
+  const updatesTableName = crdtEnabled ? tableNameOf(crdt.updatesTable) : void 0;
+  const updatesTable = crdtEnabled ? toTableResource(crdt.updatesTable) : void 0;
+  const snapshotsTableName = crdtEnabled && crdt.snapshotsTable ? tableNameOf(crdt.snapshotsTable) : void 0;
+  crdtEnabled && crdt.snapshotsTable ? toTableResource(crdt.snapshotsTable) : void 0;
+  const getDoc = (id) => {
+    const existing = docs.get(id);
+    if (existing) return existing;
+    const doc = new loroCrdt.LoroDoc();
+    docs.set(id, doc);
+    return doc;
+  };
+  const docRef = (id) => new surrealdb.RecordId(tableName, id);
+  const idFromDocRef = (doc) => toRecordKeyString(doc);
+  const resolveActor = (id, change) => {
+    if (!crdtEnabled) return void 0;
+    const candidate = crdt.actor ?? crdt.localActorId;
+    if (typeof candidate === "function") {
+      return candidate({ id, change });
+    }
+    return candidate;
   };
-  const loroPut = (row, commit = true) => {
-    if (!loroMap) return;
-    loroMap.set(getKey(row), toLoroStoredRow(row));
-    if (commit) commitLoro();
+  const decodeUpdateBytes = async (row, kind) => {
+    if (!e2eeEnabled) {
+      if (kind === "snapshot") {
+        const snapshot = row.snapshot_bytes;
+        if (!snapshot) return new Uint8Array();
+        return fromBase64(snapshot);
+      }
+      const update = row.update_bytes;
+      if (!update) return new Uint8Array();
+      return fromBase64(update);
+    }
+    const envelope = toEnvelope(row);
+    if (!envelope) return new Uint8Array();
+    const id = idFromDocRef(row.doc);
+    return e2ee.crypto.decrypt({
+      envelope,
+      aad: aadFor({
+        table: kind === "snapshot" ? snapshotsTableName ?? tableName : updatesTableName ?? tableName,
+        baseTable: tableName,
+        id,
+        kind
+      })
+    });
   };
-  const loroRemove = (idStr, commit = true) => {
-    if (!loroMap) return;
-    loroMap.delete(idStr);
-    if (commit) commitLoro();
+  const encodeUpdatePayload = async (bytes, id, kind) => {
+    if (!e2eeEnabled) {
+      return { update_bytes: toBase64(bytes) };
+    }
+    const targetTable = updatesTableName;
+    const envelope = await e2ee.crypto.encrypt({
+      plaintext: bytes,
+      aad: aadFor({
+        table: targetTable ?? tableName,
+        baseTable: tableName,
+        id,
+        kind
+      })
+    });
+    return toStoredEnvelope(envelope);
   };
-  const mergeLocalOverServer = (serverRows) => {
-    if (!useLoro || !loroMap) return serverRows;
-    const localJson = loroMap.toJSON?.() ?? {};
-    const out = [];
-    for (const s of serverRows) {
-      const idStr = getKey(s);
-      const l = localJson[idStr];
-      if (!l) {
-        out.push(s);
-        continue;
+  const persistCrdtUpdate = async (id, bytes, change) => {
+    if (!crdtEnabled || !updatesTable) return;
+    const payload = await encodeUpdatePayload(bytes, id, "update");
+    const actor = resolveActor(id, change);
+    const row = {
+      doc: docRef(id),
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      ...actor ? { actor } : {},
+      ...payload
+    };
+    await db.create(updatesTable).content(row);
+  };
+  const persistMaterialized = async (materialized) => {
+    if (!crdtEnabled || crdt.persistMaterializedView !== true) return;
+    const id = toRecordKeyString(materialized.id);
+    if (!e2eeEnabled) {
+      const { id: _ignoredId, ...rest } = materialized;
+      await db.upsert(normalizeMutationId(materialized.id)).merge(rest);
+      return;
+    }
+    const payload = await encodeBaseRow(
+      omitUndefined({
+        ...materialized,
+        id: void 0
+      }),
+      id
+    );
+    await db.upsert(normalizeMutationId(materialized.id)).merge(payload);
+  };
+  const hydratePlainRows = async (rows, write, begin, commit, type = "insert") => {
+    if (!rows.length) return;
+    begin();
+    try {
+      for (const row of rows) {
+        const decoded = await decodeBaseRow(row);
+        write({ type, value: decoded });
       }
-      if ((l.sync_deleted ?? false) === true) continue;
-      out.push(withRecordId(l));
+    } finally {
+      commit();
     }
-    return out;
+  };
+  const hydrateCrdtDoc = async (id, write, begin, commit, writeType = "insert") => {
+    if (!crdtEnabled || !updatesTableName) return;
+    const doc = getDoc(id);
+    let since;
+    if (snapshotsTableName) {
+      const snapshots = await queryRows(
+        db,
+        `SELECT * FROM type::table($table) WHERE doc = $doc ORDER BY ts DESC LIMIT 1;`,
+        {
+          table: snapshotsTableName,
+          doc: docRef(id)
+        }
+      );
+      const snapshot = snapshots[0];
+      if (snapshot) {
+        const bytes = await decodeUpdateBytes(snapshot, "snapshot");
+        if (bytes.byteLength) doc.import(bytes);
+        since = typeof snapshot.ts === "string" ? snapshot.ts : snapshot.ts instanceof Date ? snapshot.ts.toISOString() : void 0;
+      }
+    }
+    const updates = await queryRows(
+      db,
+      since ? `SELECT * FROM type::table($table) WHERE doc = $doc AND ts > $since ORDER BY ts ASC;` : `SELECT * FROM type::table($table) WHERE doc = $doc ORDER BY ts ASC;`,
+      {
+        table: updatesTableName,
+        doc: docRef(id),
+        since
+      }
+    );
+    for (const update of updates) {
+      const bytes = await decodeUpdateBytes(update, "update");
+      if (!bytes.byteLength) continue;
+      doc.import(bytes);
+    }
+    const materialized = normalizeRow(materializeCrdt(doc, id));
+    begin();
+    try {
+      write({ type: writeType, value: materialized });
+    } finally {
+      commit();
+    }
+  };
+  const updateActiveOnDemandIds = () => {
+    activeOnDemandIds.clear();
+    for (const ids of subsetIds.values()) {
+      for (const id of ids) activeOnDemandIds.add(id);
+    }
+  };
+  const createSyncRuntime = (ctx) => {
+    let cleanupBaseLive = NOOP;
+    let cleanupUpdateLive = NOOP;
+    let killed = false;
+    const ensureBaseLive = async () => {
+      if (cleanupBaseLive !== NOOP) return;
+      if (!db.isFeatureSupported?.(surrealdb.Features.LiveQueries)) return;
+      const live = await db.live(tableResource);
+      if (killed) {
+        await live.kill();
+        return;
+      }
+      live.subscribe(async (message) => {
+        if (message.action === "KILLED") return;
+        const row = message.value;
+        const id = toRecordKeyString(row.id);
+        const wasVisible = activeOnDemandIds.has(id);
+        if (isStrictOnDemand && !wasVisible && message.action !== "DELETE") return;
+        if (message.action === "DELETE") {
+          for (const ids of subsetIds.values()) ids.delete(id);
+          updateActiveOnDemandIds();
+          if (isStrictOnDemand && !wasVisible) return;
+          ctx.begin();
+          try {
+            ctx.write({ type: "delete", key: `${tableName}:${id}` });
+          } finally {
+            ctx.commit();
+          }
+          return;
+        }
+        const decoded = await decodeBaseRow(row);
+        ctx.begin();
+        try {
+          ctx.write({
+            type: message.action === "CREATE" ? "insert" : "update",
+            value: decoded
+          });
+        } finally {
+          ctx.commit();
+        }
+      });
+      cleanupBaseLive = () => {
+        void live.kill().catch(() => void 0);
+        cleanupBaseLive = NOOP;
+      };
+    };
+    const ensureUpdateLive = async () => {
+      if (!crdtEnabled || !updatesTable) return;
+      if (cleanupUpdateLive !== NOOP) return;
+      if (!db.isFeatureSupported?.(surrealdb.Features.LiveQueries)) return;
+      const live = await db.live(updatesTable);
+      if (killed) {
+        await live.kill();
+        return;
+      }
+      live.subscribe(async (message) => {
+        if (message.action === "KILLED") return;
+        if (message.action === "DELETE") return;
+        const value = message.value;
+        const id = idFromDocRef(value.doc);
+        if (value.actor && value.actor === resolveActor(id)) return;
+        if (isStrictOnDemand && !activeOnDemandIds.has(id)) return;
+        const doc = getDoc(id);
+        const bytes = await decodeUpdateBytes(value, "update");
+        if (!bytes.byteLength) return;
+        doc.import(bytes);
+        const materialized = normalizeRow(materializeCrdt(doc, id));
+        ctx.begin();
+        try {
+          ctx.write({ type: "update", value: materialized });
+        } finally {
+          ctx.commit();
+        }
+      });
+      cleanupUpdateLive = () => {
+        void live.kill().catch(() => void 0);
+        cleanupUpdateLive = NOOP;
+      };
+    };
+    const loadSubset = async (subset) => {
+      if (!isOnDemandLike) return;
+      const key = subsetCacheKey(subset);
+      const rows = await tableAccess.loadSubset(subset);
+      const ids = new Set(
+        rows.map(
+          (row) => toRecordKeyString(row.id)
+        )
+      );
+      subsetIds.set(key, ids);
+      updateActiveOnDemandIds();
+      if (!crdtEnabled) {
+        await hydratePlainRows(
+          rows,
+          ctx.write,
+          ctx.begin,
+          ctx.commit,
+          "insert"
+        );
+        await ensureBaseLive();
+        return;
+      }
+      for (const id of ids) {
+        await hydrateCrdtDoc(id, ctx.write, ctx.begin, ctx.commit, "insert");
+      }
+      await ensureUpdateLive();
+    };
+    const unloadSubset = (subset) => {
+      if (!isOnDemandLike) return;
+      const key = subsetCacheKey(subset);
+      subsetIds.delete(key);
+      updateActiveOnDemandIds();
+      if (subsetIds.size === 0) {
+        cleanupBaseLive();
+        cleanupUpdateLive();
+      }
+    };
+    const startRealtime = async () => {
+      if (!crdtEnabled) {
+        await ensureBaseLive();
+        return;
+      }
+      await ensureUpdateLive();
+    };
+    const cleanup = () => {
+      killed = true;
+      subsetIds.clear();
+      updateActiveOnDemandIds();
+      cleanupBaseLive();
+      cleanupUpdateLive();
+    };
+    return {
+      startRealtime,
+      cleanup,
+      loadSubset,
+      unloadSubset
+    };
   };
   const base = queryDbCollection.queryCollectionOptions({
-    schema: createInsertSchema(config.table.name),
+    schema: createInsertSchema(tableName),
     getKey,
-    queryKey: resolvedQueryKey,
+    queryKey,
     queryClient,
-    syncMode,
+    syncMode: queryDrivenSyncMode,
     queryFn: async ({ meta }) => {
       try {
-        const subset = syncMode === "on-demand" ? meta?.loadSubsetOptions : void 0;
-        normalizeSubsetLiteralsInPlace(subset);
-        const rows = syncMode === "eager" ? await table.listAll() : await table.loadSubset(subset);
-        return mergeLocalOverServer(rows).map(
-          (row) => withRecordId(row)
+        if (isOnDemandLike && !meta?.loadSubsetOptions) {
+          return [];
+        }
+        if (!crdtEnabled) {
+          if (!isOnDemandLike) {
+            const rows2 = await toRecordArray(await db.select(tableResource));
+            const decoded2 = await Promise.all(
+              rows2.map((row) => decodeBaseRow(row))
+            );
+            return decoded2;
+          }
+          const rows = await tableAccess.loadSubset(meta?.loadSubsetOptions);
+          const decoded = await Promise.all(
+            rows.map(
+              (row) => decodeBaseRow(row)
+            )
+          );
+          return decoded;
+        }
+        if (isOnDemandLike) return [];
+        if (!updatesTableName) return [];
+        const updates = await queryRows(
+          db,
+          `SELECT * FROM type::table($table) ORDER BY ts ASC;`,
+          { table: updatesTableName }
         );
-      } catch (e) {
-        onError?.(e);
+        for (const update of updates) {
+          const id = idFromDocRef(update.doc);
+          const doc = getDoc(id);
+          const bytes = await decodeUpdateBytes(update, "update");
+          if (!bytes.byteLength) continue;
+          doc.import(bytes);
+        }
+        return [...docs.entries()].map(
+          ([id, doc]) => normalizeRow(materializeCrdt(doc, id))
+        );
+      } catch (error) {
+        onError?.(error);
         return [];
       }
     },
-    onInsert: (async (p) => {
-      const now = /* @__PURE__ */ new Date();
-      const resultRows = [];
-      let shouldCommitLoro = false;
-      for (const m of p.transaction.mutations) {
-        if (m.type !== "insert") continue;
-        const baseRow = { ...m.modified };
-        const row = useLoro ? {
-          ...baseRow,
-          updated_at: now,
-          sync_deleted: false
-        } : baseRow;
-        const normalizedRow = withRecordId(row);
-        if (useLoro) {
-          loroPut(normalizedRow, false);
-          shouldCommitLoro = true;
-        }
-        if (isTempId(normalizedRow.id, config.table.name)) {
-          const tempKey = keyOf(normalizedRow.id);
-          const { id: _id, ...payload } = normalizedRow;
-          const persisted = await table.create(payload);
-          const resolvedRow = persisted?.id ? withRecordId({
-            ...normalizedRow,
-            ...persisted,
-            id: persisted.id
-          }) : normalizedRow;
-          if (useLoro && persisted?.id) {
-            loroRemove(tempKey, false);
-            loroPut(resolvedRow, false);
+    onInsert: (async (params) => {
+      const out = [];
+      const writeUtils = getWriteUtils(params.collection.utils);
+      for (const mutation of params.transaction.mutations) {
+        if (mutation.type !== "insert") continue;
+        const normalized = normalizeRow(mutation.modified);
+        if (!crdtEnabled) {
+          const idKey = toRecordKeyString(normalized.id);
+          const payload = omitUndefined({
+            ...normalized,
+            id: void 0
+          });
+          const recordPayload = await encodeBaseRow(payload, idKey);
+          if (isTempId(normalized.id, tableName)) {
+            const created = await db.create(tableResource).content(recordPayload);
+            const createdRow = firstRow2(
+              toRecordArray(created)
+            );
+            const createdId = createdRow && createdRow.id ? createdRow.id : normalized.id;
+            const resolved = {
+              ...normalized,
+              id: normalizeMutationId(createdId)
+            };
+            out.push(resolved);
+            writeUtils.writeUpsert?.(resolved);
+            continue;
           }
-          resultRows.push(resolvedRow);
-        } else {
-          const persisted = await table.create(normalizedRow);
-          resultRows.push(
-            persisted ? withRecordId({
-              ...normalizedRow,
-              ...persisted
-            }) : normalizedRow
-          );
+          await db.insert(tableResource, {
+            id: normalizeMutationId(normalized.id),
+            ...recordPayload
+          });
+          out.push(normalized);
+          writeUtils.writeUpsert?.(normalized);
+          continue;
         }
+        const id = toRecordKeyString(normalized.id);
+        const doc = getDoc(id);
+        const vv = doc.oplogVersion();
+        const localChange = {
+          type: "insert",
+          value: normalized
+        };
+        applyCrdtLocalChange(doc, localChange);
+        const bytes = doc.export({ mode: "update", from: vv });
+        await persistCrdtUpdate(id, bytes, localChange);
+        const materialized = normalizeRow(materializeCrdt(doc, id));
+        await persistMaterialized(materialized);
+        out.push(materialized);
+        writeUtils.writeUpsert?.(materialized);
       }
-      if (shouldCommitLoro) commitLoro();
-      return resultRows;
+      return out;
     }),
-    onUpdate: (async (p) => {
-      const now = /* @__PURE__ */ new Date();
-      const writeUtils = getWriteUtils(p.collection.utils);
-      let shouldCommitLoro = false;
-      for (const m of p.transaction.mutations) {
-        if (m.type !== "update") continue;
-        const idKey = m.key;
+    onUpdate: (async (params) => {
+      const writeUtils = getWriteUtils(params.collection.utils);
+      for (const mutation of params.transaction.mutations) {
+        if (mutation.type !== "update") continue;
+        const mutationId = normalizeMutationId(mutation.key);
         const normalizedModified = omitUndefined(
           normalizeRecordIdLikeFields({
-            ...m.modified
+            ...mutation.modified
           })
         );
-        const baseRow = {
+        const normalized = normalizeRow({
           ...normalizedModified,
-          id: normalizeMutationId(idKey)
-        };
-        const row = useLoro ? { ...baseRow, updated_at: now } : baseRow;
-        const normalizedRow = withRecordId(row);
-        if (useLoro) {
-          loroPut(normalizedRow, false);
-          shouldCommitLoro = true;
+          id: mutationId
+        });
+        if (!crdtEnabled) {
+          if (!e2eeEnabled) {
+            await db.update(mutationId).merge(normalizedModified);
+            writeUtils.writeUpsert?.(normalized);
+            continue;
+          }
+          const current = await db.select(mutationId);
+          const currentRows = toRecordArray(
+            current
+          );
+          const currentRow = currentRows[0];
+          const decodedCurrent = currentRow ? await decodeBaseRow(currentRow) : { id: mutationId };
+          const merged = {
+            ...decodedCurrent,
+            ...normalizedModified
+          };
+          delete merged.id;
+          const encoded = await encodeBaseRow(
+            omitUndefined(merged),
+            toRecordKeyString(mutationId)
+          );
+          await db.update(mutationId).merge(encoded);
+          writeUtils.writeUpsert?.(normalizeRow({ ...decodedCurrent, ...merged }));
+          continue;
         }
-        await table.update(normalizeMutationId(idKey), normalizedRow);
-        writeUtils.writeUpsert?.(normalizedRow);
+        const id = toRecordKeyString(mutationId);
+        const doc = getDoc(id);
+        const vv = doc.oplogVersion();
+        const localChange = {
+          type: "update",
+          value: normalized
+        };
+        applyCrdtLocalChange(doc, localChange);
+        const bytes = doc.export({ mode: "update", from: vv });
+        await persistCrdtUpdate(id, bytes, localChange);
+        const materialized = normalizeRow(materializeCrdt(doc, id));
+        await persistMaterialized(materialized);
+        writeUtils.writeUpsert?.(materialized);
       }
-      if (shouldCommitLoro) commitLoro();
       return { refetch: false };
     }),
-    onDelete: (async (p) => {
-      const writeUtils = getWriteUtils(p.collection.utils);
-      let shouldCommitLoro = false;
-      for (const m of p.transaction.mutations) {
-        if (m.type !== "delete") continue;
-        const idKey = m.key;
-        const key = keyOf(idKey);
-        if (useLoro) {
-          loroRemove(key, false);
-          shouldCommitLoro = true;
+    onDelete: (async (params) => {
+      const writeUtils = getWriteUtils(params.collection.utils);
+      for (const mutation of params.transaction.mutations) {
+        if (mutation.type !== "delete") continue;
+        const mutationId = normalizeMutationId(mutation.key);
+        const id = toRecordKeyString(mutationId);
+        if (!crdtEnabled) {
+          await db.delete(mutationId);
+          writeUtils.writeDelete?.(`${tableName}:${id}`);
+          continue;
         }
-        await table.softDelete(normalizeMutationId(idKey));
-        writeUtils.writeDelete?.(key);
+        const doc = getDoc(id);
+        const vv = doc.oplogVersion();
+        const localChange = {
+          type: "delete",
+          value: { id: mutationId }
+        };
+        applyCrdtLocalChange(doc, localChange);
+        const bytes = doc.export({ mode: "update", from: vv });
+        await persistCrdtUpdate(id, bytes, localChange);
+        writeUtils.writeDelete?.(`${tableName}:${id}`);
       }
-      if (shouldCommitLoro) commitLoro();
       return { refetch: false };
     })
   });
   const baseSync = base.sync?.sync;
   const sync = baseSync ? {
     sync: (ctx) => {
-      patchSubscribeChangesForRecordIds(
-        ctx.collection
-      );
-      const baseRes = baseSync(ctx);
-      const baseCleanup = toCleanup(baseRes);
-      if (!db.isFeatureSupported(surrealdb.Features.LiveQueries)) {
-        return baseRes;
-      }
-      const offLive = table.subscribe((evt) => {
-        if (useLoro) {
-          if (evt.type === "delete") {
-            loroRemove(getKey(evt.row));
-          } else {
-            loroPut(evt.row);
+      const canRunBaseSync = typeof ctx.collection?.on === "function";
+      const baseResult = canRunBaseSync ? baseSync(ctx) : void 0;
+      const baseCleanup = typeof baseResult === "function" ? baseResult : typeof baseResult === "object" && baseResult && "cleanup" in baseResult && typeof baseResult.cleanup === "function" ? baseResult.cleanup : NOOP;
+      const runtime = createSyncRuntime(ctx);
+      const start = async () => {
+        if (!isOnDemandLike) {
+          if (!crdtEnabled) {
+            const rows = toRecordArray(
+              await db.select(tableResource)
+            );
+            await hydratePlainRows(rows, ctx.write, ctx.begin, ctx.commit, "insert");
+            await runtime.startRealtime();
+            ctx.markReady();
+            return;
           }
-        }
-        void queryClient.invalidateQueries({ queryKey, exact: false }).catch((e) => onError?.(e));
-      });
-      if (hasLoadSubset(baseRes)) {
-        const resObj = baseRes;
-        const rawLoadSubset = resObj.loadSubset;
-        const loadSubset = typeof rawLoadSubset === "function" ? (opts) => {
-          normalizeSubsetLiteralsInPlace(opts);
-          return rawLoadSubset(opts);
-        } : rawLoadSubset;
-        return {
-          ...resObj,
-          loadSubset,
-          cleanup: () => {
-            offLive();
-            baseCleanup();
+          if (updatesTableName) {
+            const updates = await queryRows(
+              db,
+              `SELECT * FROM type::table($table) ORDER BY ts ASC;`,
+              { table: updatesTableName }
+            );
+            for (const update of updates) {
+              const id = idFromDocRef(update.doc);
+              const doc = getDoc(id);
+              const bytes = await decodeUpdateBytes(update, "update");
+              if (!bytes.byteLength) continue;
+              doc.import(bytes);
+            }
+            ctx.begin();
+            try {
+              for (const [id, doc] of docs.entries()) {
+                ctx.write({
+                  type: "insert",
+                  value: normalizeRow(materializeCrdt(doc, id))
+                });
+              }
+            } finally {
+              ctx.commit();
+            }
+            await runtime.startRealtime();
           }
-        };
-      }
-      return (() => {
-        offLive();
-        baseCleanup();
-      });
+          ctx.markReady();
+          return;
+        }
+        ctx.markReady();
+        if (syncMode === "progressive") {
+          void runtime.loadSubset({}).catch((error) => onError?.(error));
+        }
+      };
+      void start().catch((error) => onError?.(error));
+      return {
+        cleanup: () => {
+          runtime.cleanup();
+          baseCleanup();
+        },
+        loadSubset: async (subset) => {
+          await runtime.loadSubset(subset);
+        },
+        unloadSubset: (subset) => {
+          runtime.unloadSubset(subset);
+        }
+      };
     }
   } : void 0;
   return {
@@ -856,8 +1325,16 @@ function surrealCollectionOptions({
     sync: sync ?? base.sync
   };
 }
+function surrealCollectionOptions(config) {
+  return modernSurrealCollectionOptions(config);
+}
 
-exports.eqRecordId = eqRecordId;
+exports.WebCryptoAESGCM = WebCryptoAESGCM;
+exports.applyLoroJsonChange = applyLoroJsonChange;
+exports.applyLoroRichtextChange = applyLoroRichtextChange;
+exports.createLoroProfile = createLoroProfile;
+exports.materializeLoroJson = materializeLoroJson;
+exports.materializeLoroRichtext = materializeLoroRichtext;
 exports.surrealCollectionOptions = surrealCollectionOptions;
 exports.toRecordKeyString = toRecordKeyString;
 //# sourceMappingURL=index.js.map