@korajs/store 0.5.0 → 1.0.0-beta.0

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   decodeAuditExport,
   readAuditExportManifest,
   verifyAuditExportChecksum
-} from "./chunk-AGN3CIPB.js";
+} from "./chunk-EIVXWF4B.js";
 import {
   persistedAuditTraceFromEvent
 } from "./chunk-MYSJN3DF.js";
@@ -11,46 +11,53 @@ import {
   allocateNextSequenceInTransaction,
   allocateNextSequenceNumber,
   buildCountQuery,
+  buildFieldFastForwardUpdateQuery,
   buildInsertQuery,
   buildLwwSoftDeleteQuery,
-  buildLwwUpdateQuery,
   buildSelectQuery,
   buildSoftDeleteQuery,
   buildUpdateQuery,
   executeDelete,
   executeInsert,
   executeUpdate,
+  fieldVersionsForFields,
   isIncomingNewerThanRow,
+  parseFieldVersions,
   readSequenceNumber,
+  resolvePerFieldLww,
+  serializeFieldVersions,
   serializeRowVersion,
   validateStateTransition,
   validateUpdateStateMachine
-} from "./chunk-7BPETY5Y.js";
+} from "./chunk-OUQDC5Z6.js";
 import {
   AdapterError,
+  OptimisticLockError,
   PersistenceError,
   QueryError,
   RecordNotFoundError,
   StoreNotOpenError,
   WorkerInitError,
   WorkerTimeoutError
-} from "./chunk-LAWV6CFH.js";
+} from "./chunk-QL2XVZRN.js";
 import {
   exportBackup,
   readBackupManifest,
   restoreBackup,
   verifyBackupChecksum
-} from "./chunk-EZSTD2XC.js";
+} from "./chunk-5R4QMY3Z.js";
 import {
   decodeRichtext,
+  decodeRichtextFieldsFromOpData,
   deserializeOperationWithCollection,
   deserializeRecord,
   encodeRichtext,
+  encodeRichtextFieldsForOpData,
   richtextStatesEqual,
   richtextToPlainText,
   serializeOperation,
   serializeRecord
-} from "./chunk-56LL4XP6.js";
+} from "./chunk-ETDJEH2I.js";
 
 // src/compaction/types.ts
 var COMPACTION_BASELINE_META_KEY = "compaction_baseline_at";
@@ -195,7 +202,7 @@ async function saveDeltaCursor(adapter, cursor) {
 // src/store/store.ts
 import {
   CausalTracker,
-  HybridLogicalClock as HybridLogicalClock2,
+  HybridLogicalClock as HybridLogicalClock3,
   createVersionVector as createVersionVector3,
   generateUUIDv7 as generateUUIDv73,
   migrationStepsToSQL
@@ -885,7 +892,9 @@ function applyOperationToMemory(state, op, schema) {
       }
       colMap.set(op.recordId, {
         id: op.recordId,
-        fields: { ...op.data },
+        // op.data stores binary richtext as tagged JSON; snapshots must
+        // expose record-shaped values (Uint8Array/string).
+        fields: decodeRichtextFieldsFromOpData(op.data, definition.fields),
         deleted: false,
         createdAt: wallTime,
         updatedAt: wallTime
@@ -896,9 +905,10 @@ function applyOperationToMemory(state, op, schema) {
       if (!op.data) {
         return;
       }
+      const decodedData = decodeRichtextFieldsFromOpData(op.data, definition.fields);
       const existing = colMap.get(op.recordId);
       if (existing && !existing.deleted) {
-        existing.fields = { ...existing.fields, ...op.data };
+        existing.fields = { ...existing.fields, ...decodedData };
         existing.updatedAt = wallTime;
         break;
       }
@@ -907,7 +917,7 @@ function applyOperationToMemory(state, op, schema) {
       }
       colMap.set(op.recordId, {
         id: op.recordId,
-        fields: { ...op.data },
+        fields: decodedData,
         deleted: false,
         createdAt: wallTime,
         updatedAt: wallTime
@@ -1458,6 +1468,137 @@ var SubscriptionManager = class {
   }
 };
 
+// src/sync/rebase-unsynced-operations.ts
+import { HybridLogicalClock as HybridLogicalClock2, MAX_LOGICAL } from "@korajs/core";
+import { computeOperationId } from "@korajs/core/internal";
+var LOGICAL_COUNTER_LIMIT = MAX_LOGICAL + 1;
+function emptyResult() {
+  return { operations: [], idMapping: {}, rebasedCount: 0, newMaxTimestamp: null };
+}
+async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, correctedNowMs) {
+  if (unsyncedOpIds.length === 0) {
+    return emptyResult();
+  }
+  const rebaseIds = new Set(unsyncedOpIds);
+  const rebased = [];
+  let maxOtherSerializedTs = null;
+  for (const collectionName of Object.keys(schema.collections)) {
+    const rows = await adapter.query(`SELECT * FROM _kora_ops_${collectionName}`);
+    for (const row of rows) {
+      if (rebaseIds.has(row.id)) {
+        rebased.push(deserializeOperationWithCollection(row, collectionName));
+      } else if (maxOtherSerializedTs === null || row.timestamp > maxOtherSerializedTs) {
+        maxOtherSerializedTs = row.timestamp;
+      }
+    }
+  }
+  if (rebased.length === 0) {
+    return emptyResult();
+  }
+  const maxOtherWallTime = maxOtherSerializedTs === null ? Number.NEGATIVE_INFINITY : HybridLogicalClock2.deserialize(maxOtherSerializedTs).wallTime;
+  const baseWallTime = Math.max(correctedNowMs, maxOtherWallTime + 1);
+  rebased.sort((a, b) => HybridLogicalClock2.compare(a.timestamp, b.timestamp));
+  const newTimestamps = rebased.map((op, i) => ({
+    // Spill into wallTime past the 5-digit logical serialization limit so the
+    // serialized order stays correct even for enormous offline queues.
+    wallTime: baseWallTime + Math.floor(i / LOGICAL_COUNTER_LIMIT),
+    logical: i % LOGICAL_COUNTER_LIMIT,
+    nodeId: op.nodeId
+  }));
+  const idMapping = {};
+  const newIds = [];
+  for (let i = 0; i < rebased.length; i++) {
+    const op = rebased[i];
+    const ts = newTimestamps[i];
+    if (!op || !ts) {
+      continue;
+    }
+    const input = {
+      nodeId: op.nodeId,
+      type: op.type,
+      collection: op.collection,
+      recordId: op.recordId,
+      data: op.data,
+      previousData: op.previousData,
+      sequenceNumber: op.sequenceNumber,
+      causalDeps: op.causalDeps,
+      schemaVersion: op.schemaVersion,
+      ...op.atomicOps !== void 0 ? { atomicOps: op.atomicOps } : {}
+    };
+    const newId = await computeOperationId(input, HybridLogicalClock2.serialize(ts));
+    idMapping[op.id] = newId;
+    newIds.push(newId);
+  }
+  const newOperations = [];
+  for (let i = 0; i < rebased.length; i++) {
+    const op = rebased[i];
+    const ts = newTimestamps[i];
+    const newId = newIds[i];
+    if (!op || !ts || newId === void 0) {
+      continue;
+    }
+    newOperations.push({
+      ...op,
+      id: newId,
+      timestamp: ts,
+      causalDeps: op.causalDeps.map((dep) => idMapping[dep] ?? dep)
+    });
+  }
+  await adapter.transaction(async (tx) => {
+    for (let i = 0; i < rebased.length; i++) {
+      const oldOp = rebased[i];
+      const newOp = newOperations[i];
+      if (!oldOp || !newOp) {
+        continue;
+      }
+      const opsTable = `_kora_ops_${oldOp.collection}`;
+      await tx.execute(`DELETE FROM ${opsTable} WHERE id = ?`, [oldOp.id]);
+      const opInsert = buildInsertQuery(
+        opsTable,
+        serializeOperation(newOp)
+      );
+      await tx.execute(opInsert.sql, opInsert.params);
+      const oldVersion = serializeRowVersion(oldOp.timestamp);
+      const newVersion = serializeRowVersion(newOp.timestamp);
+      await tx.execute(
+        `UPDATE ${oldOp.collection} SET _version = ?, _updated_at = ? WHERE id = ? AND _version = ?`,
+        [newVersion, newOp.timestamp.wallTime, oldOp.recordId, oldVersion]
+      );
+      const rows = await tx.query(
+        `SELECT _field_versions FROM ${oldOp.collection} WHERE id = ?`,
+        [oldOp.recordId]
+      );
+      const fieldVersions = parseFieldVersions(rows[0]?._field_versions);
+      let changed = false;
+      for (const [field, version] of Object.entries(fieldVersions)) {
+        if (version === oldVersion) {
+          fieldVersions[field] = newVersion;
+          changed = true;
+        }
+      }
+      if (changed) {
+        await tx.execute(`UPDATE ${oldOp.collection} SET _field_versions = ? WHERE id = ?`, [
+          serializeFieldVersions(fieldVersions),
+          oldOp.recordId
+        ]);
+      }
+      if (oldOp.type === "insert") {
+        await tx.execute(
+          `UPDATE ${oldOp.collection} SET _created_at = ? WHERE id = ? AND _created_at = ?`,
+          [newOp.timestamp.wallTime, oldOp.recordId, oldOp.timestamp.wallTime]
+        );
+      }
+    }
+  });
+  const newMaxTimestamp = newTimestamps[newTimestamps.length - 1] ?? null;
+  return {
+    operations: newOperations,
+    idMapping,
+    rebasedCount: newOperations.length,
+    newMaxTimestamp
+  };
+}
+
 // src/transaction/transaction-context.ts
 import {
   createOperation as createOperation2,
@@ -1607,7 +1748,9 @@ var TransactionContext = class {
         type: "insert",
         collection: collectionName,
         recordId,
-        data: { ...validated },
+        // Binary richtext values are tagged as canonical JSON before the
+        // operation is content-hashed (see encodeRichtextFieldsForOpData).
+        data: encodeRichtextFieldsForOpData(validated, definition.fields),
         previousData: null,
         sequenceNumber,
         causalDeps,
@@ -1678,8 +1821,10 @@ var TransactionContext = class {
         type: "update",
         collection: collectionName,
         recordId: id,
-        data: { ...resolvedData },
-        previousData,
+        // Binary richtext values (new and previous) are tagged as canonical
+        // JSON before the operation is content-hashed.
+        data: encodeRichtextFieldsForOpData(resolvedData, definition.fields),
+        previousData: encodeRichtextFieldsForOpData(previousData, definition.fields),
         sequenceNumber,
         causalDeps,
         schemaVersion: this.config.schema.version,
@@ -1786,14 +1931,16 @@ var TransactionContext = class {
       if (entry.operation.type === "insert" && entry.operation.data) {
         record = {
           id,
-          ...entry.operation.data,
+          // op.data stores binary richtext as tagged JSON; the effective
+          // record must expose record-shaped values (Uint8Array/string).
+          ...decodeRichtextFieldsFromOpData(entry.operation.data, definition.fields),
           createdAt: entry.operation.timestamp.wallTime,
           updatedAt: entry.operation.timestamp.wallTime
         };
       } else if (entry.operation.type === "update" && entry.operation.data && record) {
         record = {
           ...record,
-          ...entry.operation.data,
+          ...decodeRichtextFieldsFromOpData(entry.operation.data, definition.fields),
           updatedAt: entry.operation.timestamp.wallTime
         };
       } else if (entry.operation.type === "delete") {
@@ -1893,7 +2040,7 @@ var Store = class {
     await this.adapter.open(this.schema);
     await this.runMigrationsIfNeeded();
     this.nodeId = await this.loadOrGenerateNodeId();
-    this.clock = new HybridLogicalClock2(this.nodeId);
+    this.clock = new HybridLogicalClock3(this.nodeId);
     this.causalTracker = new CausalTracker();
     this.sequenceManager = new SequenceManager(this.adapter, this.nodeId);
     this.sequenceNumber = await this.loadSequenceNumber();
@@ -1980,6 +2127,14 @@ var Store = class {
   /**
    * Get the node ID for this store instance.
    */
+  /**
+   * Records the offset between server time and this device's clock
+   * (serverTime - localTime), learned at sync handshake. Lets the store's HLC
+   * validate remote timestamps correctly even when the local clock is wrong.
+   */
+  setClockReferenceOffset(offsetMs) {
+    this.clock?.setReferenceOffset(offsetMs);
+  }
   getNodeId() {
     this.ensureOpen();
     return this.nodeId;
@@ -2006,45 +2161,158 @@ var Store = class {
     if (this.clock) {
       this.clock.receive(op.timestamp);
     }
-    const remoteVersion = serializeRowVersion(op.timestamp);
-    const wallTime = op.timestamp.wallTime;
+    const materializeTimestamp = options?.materializeTimestamp ?? op.timestamp;
+    const remoteVersion = serializeRowVersion(materializeTimestamp);
+    const wallTime = materializeTimestamp.wallTime;
+    const materializeSource = options?.materializeData ?? op.data;
     await this.adapter.transaction(async (tx) => {
-      if (op.type === "insert" && op.data) {
+      const checkGuard = (row) => {
+        const guard = options?.guardRowState;
+        if (!guard) {
+          return;
+        }
+        const version = typeof row?._version === "string" ? row._version : null;
+        const fieldVersions = typeof row?._field_versions === "string" ? row._field_versions : null;
+        if (version !== guard.version || fieldVersions !== guard.fieldVersions) {
+          throw new OptimisticLockError(collection, op.recordId);
+        }
+      };
+      if (op.type === "insert" && materializeSource) {
+        const serializedData = serializeRecord(materializeSource, definition.fields);
         const existing2 = await tx.query(
-          `SELECT _updated_at, _version FROM ${collection} WHERE id = ?`,
+          `SELECT _updated_at, _version, _field_versions, _deleted FROM ${collection} WHERE id = ?`,
           [op.recordId]
         );
         const row = existing2[0];
-        if (row && !isIncomingNewerThanRow(op.timestamp, row)) {
-        } else {
-          const serializedData = serializeRecord(op.data, definition.fields);
+        checkGuard(row);
+        if (!row) {
           const record = {
             id: op.recordId,
             ...serializedData,
             _created_at: wallTime,
             _updated_at: wallTime,
-            _version: remoteVersion
+            _version: remoteVersion,
+            // Stamp every inserted field so per-field LWW has a real baseline.
+            _field_versions: serializeFieldVersions(
+              fieldVersionsForFields(Object.keys(serializedData), remoteVersion)
+            )
           };
           const insertQuery = buildInsertQuery(collection, record);
           await tx.execute(insertQuery.sql, insertQuery.params);
+          await this.foldOrphanedOperations(tx, collection, definition, op.recordId);
+        } else if (row._deleted === 1) {
+          if (isIncomingNewerThanRow(materializeTimestamp, row)) {
+            const fieldChanges = {
+              ...serializedData,
+              _deleted: 0,
+              _field_versions: serializeFieldVersions(
+                fieldVersionsForFields(Object.keys(serializedData), remoteVersion)
+              )
+            };
+            const upsert = buildFieldFastForwardUpdateQuery(
+              collection,
+              op.recordId,
+              fieldChanges,
+              remoteVersion,
+              wallTime,
+              { maxCreatedAt: wallTime }
+            );
+            await tx.execute(upsert.sql, upsert.params);
+          }
+        } else {
+          const currentVersions = parseFieldVersions(row._field_versions);
+          const rowVersion = typeof row._version === "string" ? row._version : void 0;
+          const fieldChanges = {};
+          let fieldVersionsJson;
+          if (options?.forceMaterialize) {
+            const merged = { ...currentVersions };
+            for (const field of Object.keys(serializedData)) {
+              fieldChanges[field] = serializedData[field];
+              merged[field] = remoteVersion;
+            }
+            fieldVersionsJson = serializeFieldVersions(merged);
+          } else {
+            const { winners, merged } = resolvePerFieldLww(
+              currentVersions,
+              Object.keys(serializedData),
+              remoteVersion,
+              rowVersion
+            );
+            for (const field of winners) {
+              fieldChanges[field] = serializedData[field];
+            }
+            fieldVersionsJson = serializeFieldVersions(merged);
+          }
+          const upsert = buildFieldFastForwardUpdateQuery(
+            collection,
+            op.recordId,
+            { ...fieldChanges, _field_versions: fieldVersionsJson },
+            remoteVersion,
+            wallTime,
+            { maxCreatedAt: wallTime }
+          );
+          await tx.execute(upsert.sql, upsert.params);
         }
-      } else if (op.type === "update" && op.data) {
-        const serializedChanges = serializeRecord(op.data, definition.fields);
-        const updatePayload = {
-          ...serializedChanges,
-          _updated_at: wallTime,
-          _version: remoteVersion
-        };
-        if (options?.reactivateIfDeleted) {
-          updatePayload._deleted = 0;
-        }
-        const updateQuery = buildLwwUpdateQuery(
-          collection,
-          op.recordId,
-          updatePayload,
-          remoteVersion
+      } else if (op.type === "update" && materializeSource) {
+        const serializedChanges = serializeRecord(materializeSource, definition.fields);
+        const changedFields = Object.keys(serializedChanges);
+        const currentRows = await tx.query(
+          `SELECT _version, _field_versions FROM ${collection} WHERE id = ?`,
+          [op.recordId]
         );
-        await tx.execute(updateQuery.sql, updateQuery.params);
+        const currentRow = currentRows[0];
+        checkGuard(currentRow);
+        if (currentRow) {
+          const currentVersions = parseFieldVersions(currentRow._field_versions);
+          const rowVersion = typeof currentRow._version === "string" ? currentRow._version : void 0;
+          if (options?.forceMaterialize) {
+            const merged = { ...currentVersions };
+            for (const field of changedFields) {
+              merged[field] = remoteVersion;
+            }
+            const fieldChanges = {
+              ...serializedChanges,
+              _field_versions: serializeFieldVersions(merged)
+            };
+            if (options?.reactivateIfDeleted) {
+              fieldChanges._deleted = 0;
+            }
+            const forceQuery = buildFieldFastForwardUpdateQuery(
+              collection,
+              op.recordId,
+              fieldChanges,
+              remoteVersion,
+              wallTime
+            );
+            await tx.execute(forceQuery.sql, forceQuery.params);
+          } else {
+            const { winners, merged } = resolvePerFieldLww(
+              currentVersions,
+              changedFields,
+              remoteVersion,
+              rowVersion
+            );
+            if (winners.length > 0 || options?.reactivateIfDeleted) {
+              const winningChanges = {
+                _field_versions: serializeFieldVersions(merged)
+              };
+              for (const field of winners) {
+                winningChanges[field] = serializedChanges[field];
+              }
+              if (options?.reactivateIfDeleted) {
+                winningChanges._deleted = 0;
+              }
+              const forceQuery = buildFieldFastForwardUpdateQuery(
+                collection,
+                op.recordId,
+                winningChanges,
+                remoteVersion,
+                wallTime
+              );
+              await tx.execute(forceQuery.sql, forceQuery.params);
+            }
+          }
+        }
       } else if (op.type === "delete") {
         const deleteQuery = buildLwwSoftDeleteQuery(
           collection,
@@ -2072,6 +2340,67 @@ var Store = class {
     this.subscriptionManager.notify(collection, op);
     return "applied";
   }
+  /**
+   * Materialize update/delete operations that were logged for a record BEFORE
+   * its insert arrived (reordered delivery). Runs inside the insert's write
+   * transaction, folding each orphan in timestamp order through the exact
+   * per-field LWW / LWW-delete rules the normal apply paths use, so the final
+   * row state equals what a device that received the operations in causal
+   * order computed. Called only when the insert created a previously-absent
+   * row — in that case every logged update/delete for the record is
+   * necessarily an orphan (rows are soft-deleted, never removed, so a row
+   * that is absent now was never materialized).
+   */
+  async foldOrphanedOperations(tx, collection, definition, recordId) {
+    const orphanRows = await tx.query(
+      `SELECT * FROM _kora_ops_${collection} WHERE record_id = ? AND type IN ('update', 'delete')`,
+      [recordId]
+    );
+    if (orphanRows.length === 0) {
+      return;
+    }
+    const orphans = orphanRows.map((r) => deserializeOperationWithCollection(r, collection)).sort((a, b) => HybridLogicalClock3.compare(a.timestamp, b.timestamp));
+    for (const orphan of orphans) {
+      const orphanVersion = serializeRowVersion(orphan.timestamp);
+      const orphanWall = orphan.timestamp.wallTime;
+      if (orphan.type === "update" && orphan.data) {
+        const orphanChanges = serializeRecord(orphan.data, definition.fields);
+        const rows = await tx.query(
+          `SELECT _version, _field_versions FROM ${collection} WHERE id = ?`,
+          [recordId]
+        );
+        const current = rows[0];
+        if (!current) {
+          continue;
+        }
+        const { winners, merged } = resolvePerFieldLww(
+          parseFieldVersions(current._field_versions),
+          Object.keys(orphanChanges),
+          orphanVersion,
+          typeof current._version === "string" ? current._version : void 0
+        );
+        if (winners.length > 0) {
+          const winningChanges = {
+            _field_versions: serializeFieldVersions(merged)
+          };
+          for (const field of winners) {
+            winningChanges[field] = orphanChanges[field];
+          }
+          const query = buildFieldFastForwardUpdateQuery(
+            collection,
+            recordId,
+            winningChanges,
+            orphanVersion,
+            orphanWall
+          );
+          await tx.execute(query.sql, query.params);
+        }
+      } else if (orphan.type === "delete") {
+        const query = buildLwwSoftDeleteQuery(collection, recordId, orphanWall, orphanVersion);
+        await tx.execute(query.sql, query.params);
+      }
+    }
+  }
   /**
    * Get operations from a node within a sequence number range.
    * Implements the OperationLog interface for computeDelta.
@@ -2157,7 +2486,7 @@ var Store = class {
    */
   async exportAudit(options) {
     this.ensureOpen();
-    const { exportAudit: doExport } = await import("./export-audit-5GV6VRDZ.js");
+    const { exportAudit: doExport } = await import("./export-audit-VPGQWNR6.js");
     return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
   }
   /**
@@ -2227,6 +2556,31 @@ var Store = class {
       deleted: row._deleted === 1
     };
   }
+  /**
+   * Raw version state of a materialized row, for optimistic-concurrency guarded
+   * applies: capture this snapshot before computing a merge, pass it as
+   * `guardRowState`, and the apply refuses to write if the row changed since.
+   * Returns null when no row exists (which is itself a valid guard state — the
+   * apply then requires the row to still be absent).
+   */
+  async getRowVersionState(collection, recordId) {
+    this.ensureOpen();
+    if (!this.schema.collections[collection]) {
+      return null;
+    }
+    const rows = await this.adapter.query(
+      `SELECT _version, _field_versions FROM ${collection} WHERE id = ?`,
+      [recordId]
+    );
+    const row = rows[0];
+    if (!row) {
+      return null;
+    }
+    return {
+      version: typeof row._version === "string" ? row._version : null,
+      fieldVersions: typeof row._field_versions === "string" ? row._field_versions : null
+    };
+  }
   /**
    * Latest operation from this device for a record (used for delete-vs-update merge on sync).
    */
@@ -2269,6 +2623,30 @@ var Store = class {
       (nodeId, fromSeq, toSeq) => this.getOperationRange(nodeId, fromSeq, toSeq)
     );
   }
+  /**
+   * Re-stamp never-acknowledged local operations after a fast device clock was
+   * corrected, so sync can resume immediately. Safe because unacknowledged
+   * operations are private to this device (like unpushed git commits);
+   * acknowledged/shared operations are immutable and never touched.
+   *
+   * After the rewrite the store's HLC is advanced past the highest new
+   * timestamp so subsequent local writes keep sorting after the rebased ops.
+   * No data-change notifications are emitted: materialized values are
+   * unchanged, only version stamps move.
+   */
+  async rebaseUnsyncedOperations(unsyncedOpIds, correctedNowMs) {
+    this.ensureOpen();
+    const result = await rebaseUnsyncedOperationsInLog(
+      this.adapter,
+      this.schema,
+      unsyncedOpIds,
+      correctedNowMs
+    );
+    if (result.newMaxTimestamp && this.clock) {
+      this.clock.advanceTo(result.newMaxTimestamp);
+    }
+    return result;
+  }
   /**
    * Count of local operations ahead of the server version vector.
    */
@@ -2318,7 +2696,7 @@ var Store = class {
     let latest = null;
     for (const row of rows) {
       const op = deserializeOperationWithCollection(row, collection);
-      if (!latest || HybridLogicalClock2.compare(op.timestamp, latest.timestamp) > 0) {
+      if (!latest || HybridLogicalClock3.compare(op.timestamp, latest.timestamp) > 0) {
         latest = op;
       }
     }
@@ -2402,7 +2780,7 @@ var Store = class {
    */
   async exportBackup(options) {
     this.ensureOpen();
-    const { exportBackup: doExport } = await import("./backup-JN3LB4YT.js");
+    const { exportBackup: doExport } = await import("./backup-5XZ7THNJ.js");
     return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
   }
   /**
@@ -2414,7 +2792,7 @@ var Store = class {
    */
   async importBackup(data, options) {
     this.ensureOpen();
-    const { restoreBackup: doRestore } = await import("./backup-JN3LB4YT.js");
+    const { restoreBackup: doRestore } = await import("./backup-5XZ7THNJ.js");
     return doRestore(this.adapter, this.schema, data, options);
   }
   /**
@@ -2568,15 +2946,494 @@ var Store = class {
     }
   }
 };
+
+// src/reactivity/query-store.ts
+var EMPTY_ARRAY = Object.freeze([]);
+var QueryStore = class {
+  snapshot = EMPTY_ARRAY;
+  listeners = /* @__PURE__ */ new Set();
+  unsubscribeQuery = null;
+  active = false;
+  queryBuilder;
+  constructor(queryBuilder) {
+    this.queryBuilder = queryBuilder;
+  }
+  /**
+   * Subscribe to snapshot changes.
+   *
+   * @returns Unsubscribe function
+   */
+  subscribe = (onStoreChange) => {
+    this.listeners.add(onStoreChange);
+    if (!this.active) {
+      this.startSubscription();
+    }
+    return () => {
+      this.listeners.delete(onStoreChange);
+      if (this.listeners.size === 0) {
+        this.stopSubscription();
+      }
+    };
+  };
+  /** Synchronous read of the latest query results. */
+  getSnapshot = () => {
+    return this.snapshot;
+  };
+  /** Tear down listeners and the underlying query subscription. */
+  destroy() {
+    this.stopSubscription();
+    this.listeners.clear();
+    this.snapshot = EMPTY_ARRAY;
+  }
+  startSubscription() {
+    this.active = true;
+    this.unsubscribeQuery = this.queryBuilder.subscribe((results) => {
+      if (!this.active) return;
+      this.snapshot = Object.freeze([...results]);
+      this.notifyListeners();
+    });
+  }
+  stopSubscription() {
+    this.active = false;
+    if (this.unsubscribeQuery) {
+      this.unsubscribeQuery();
+      this.unsubscribeQuery = null;
+    }
+  }
+  notifyListeners() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+};
+
+// src/reactivity/assert-query-ready.ts
+import { AppNotReadyError } from "@korajs/core";
+var LEGACY_PENDING_COLLECTION = "__pending__";
+function assertQueryReady(query) {
+  const descriptor = query.getDescriptor();
+  if (descriptor.collection === LEGACY_PENDING_COLLECTION) {
+    throw new AppNotReadyError(
+      "Cannot use useQuery() before app.ready. Await app.ready or wrap your UI in <KoraProvider app={app}>."
+    );
+  }
+}
+
+// src/reactivity/query-store-cache.ts
+var QueryStoreCache = class {
+  constructor(scopeKey = "default") {
+    this.scopeKey = scopeKey;
+  }
+  scopeKey;
+  entries = /* @__PURE__ */ new Map();
+  getOrCreate(queryBuilder) {
+    const key = this.getKey(queryBuilder);
+    const existing = this.entries.get(key);
+    if (existing) {
+      existing.refCount++;
+      return existing.queryStore;
+    }
+    const queryStore = new QueryStore(queryBuilder);
+    this.entries.set(key, {
+      queryStore,
+      refCount: 1
+    });
+    return queryStore;
+  }
+  release(queryBuilder) {
+    const key = this.getKey(queryBuilder);
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return;
+    }
+    entry.refCount--;
+    if (entry.refCount <= 0) {
+      entry.queryStore.destroy();
+      this.entries.delete(key);
+    }
+  }
+  clear() {
+    for (const entry of this.entries.values()) {
+      entry.queryStore.destroy();
+    }
+    this.entries.clear();
+  }
+  get size() {
+    return this.entries.size;
+  }
+  getKey(queryBuilder) {
+    return `${this.scopeKey}:${JSON.stringify(queryBuilder.getDescriptor())}`;
+  }
+};
+var sharedCache = null;
+function getSharedQueryStoreCache() {
+  if (!sharedCache) {
+    sharedCache = new QueryStoreCache();
+  }
+  return sharedCache;
+}
+
+// src/richtext/create-richtext-controller.ts
+import * as Y from "yjs";
+var LOAD_ORIGIN = "kora-load";
+var REMOTE_ORIGIN = "kora-remote";
+var DOC_CHANNEL_ORIGIN = "kora-doc-channel";
+var TEXT_KEY = "content";
+var COMPACT_AFTER_DELTAS = 20;
+var PERSIST_DEBOUNCE_MS = 400;
+function createRichTextController(options) {
+  const {
+    collection,
+    collectionName,
+    recordId,
+    fieldName,
+    store,
+    syncEngine = null,
+    useDocChannel
+  } = options;
+  const doc = new Y.Doc();
+  const text = doc.getText(TEXT_KEY);
+  const undoManager = new Y.UndoManager(text);
+  let user = options.user;
+  let disposed = false;
+  let ready = false;
+  let error = null;
+  let canUndo = false;
+  let canRedo = false;
+  let cursors = [];
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = {
+    ready: false,
+    error: null,
+    canUndo: false,
+    canRedo: false,
+    cursors: []
+  };
+  const baseUpdateRef = { current: null };
+  const pendingDeltasRef = { current: [] };
+  const docChannelActiveRef = { current: false };
+  let persistTimer = null;
+  let recordUnsubscribe = null;
+  let docChannelUnsubscribe = null;
+  let awarenessUnsubscribe = null;
+  const refreshSnapshot = () => {
+    snapshot = {
+      ready,
+      error,
+      canUndo,
+      canRedo,
+      cursors: [...cursors]
+    };
+  };
+  const notify = () => {
+    refreshSnapshot();
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const syncHistoryState = () => {
+    canUndo = undoManager.undoStack.length > 0;
+    canRedo = undoManager.redoStack.length > 0;
+    notify();
+  };
+  const getSnapshot = () => snapshot;
+  const resolveAwarenessUser = () => {
+    if (user) {
+      return user;
+    }
+    if (syncEngine) {
+      const existing = syncEngine.getAwarenessManager().getLocalState()?.user;
+      if (existing) {
+        return existing;
+      }
+    }
+    return {
+      name: "Anonymous",
+      color: "#6366f1"
+    };
+  };
+  const setCursor = (anchor, head) => {
+    if (!syncEngine) {
+      return;
+    }
+    const awareness = syncEngine.getAwarenessManager();
+    const state = {
+      user: resolveAwarenessUser(),
+      cursor: {
+        collection: collectionName,
+        recordId,
+        field: fieldName,
+        anchor,
+        head
+      }
+    };
+    awareness.setLocalState(state);
+  };
+  const clearCursor = () => {
+    if (!syncEngine) {
+      return;
+    }
+    const awareness = syncEngine.getAwarenessManager();
+    const current = awareness.getLocalState();
+    if (!current?.cursor) {
+      return;
+    }
+    if (current.cursor.collection !== collectionName || current.cursor.recordId !== recordId || current.cursor.field !== fieldName) {
+      return;
+    }
+    awareness.setLocalState({ user: current.user });
+  };
+  const applyRemoteSnapshot = (value) => {
+    const encoded = encodeRichtextInput(value);
+    if (!encoded) {
+      return;
+    }
+    const currentSnapshot = Y.encodeStateAsUpdate(doc);
+    if (updatesEqual(currentSnapshot, encoded)) {
+      return;
+    }
+    Y.applyUpdate(doc, encoded, REMOTE_ORIGIN);
+    baseUpdateRef.current = encoded;
+    pendingDeltasRef.current = [];
+    syncHistoryState();
+  };
+  const flushPersist = async () => {
+    const snapshot2 = composeRichtextSnapshot(baseUpdateRef.current, pendingDeltasRef.current);
+    if (pendingDeltasRef.current.length >= COMPACT_AFTER_DELTAS) {
+      baseUpdateRef.current = snapshot2;
+      pendingDeltasRef.current = [];
+    }
+    try {
+      await collection.update(recordId, {
+        [fieldName]: snapshot2
+      });
+    } catch (cause) {
+      if (!disposed) {
+        error = cause instanceof Error ? cause : new Error(String(cause));
+        notify();
+      }
+    }
+  };
+  const schedulePersist = () => {
+    if (persistTimer) {
+      clearTimeout(persistTimer);
+    }
+    persistTimer = setTimeout(() => {
+      persistTimer = null;
+      void flushPersist();
+    }, PERSIST_DEBOUNCE_MS);
+  };
+  const onDocUpdate = (update, origin) => {
+    syncHistoryState();
+    if (origin === LOAD_ORIGIN || origin === REMOTE_ORIGIN || origin === DOC_CHANNEL_ORIGIN) {
+      return;
+    }
+    pendingDeltasRef.current.push(update);
+    if (docChannelActiveRef.current && syncEngine) {
+      syncEngine.getRichtextDocChannel?.().send(collectionName, recordId, fieldName, update);
+      schedulePersist();
+      return;
+    }
+    void flushPersist();
+  };
+  const subscribeRecordChanges = () => {
+    recordUnsubscribe?.();
+    recordUnsubscribe = store.collection(collectionName).where({ id: recordId }).subscribe((results) => {
+      const record = results[0];
+      if (!record) {
+        return;
+      }
+      applyRemoteSnapshot(record[fieldName]);
+    });
+  };
+  const subscribeDocChannel = () => {
+    docChannelUnsubscribe?.();
+    if (!ready || !syncEngine || !docChannelActiveRef.current) {
+      return;
+    }
+    const channel = syncEngine.getRichtextDocChannel?.();
+    if (!channel) {
+      return;
+    }
+    docChannelUnsubscribe = channel.subscribe(collectionName, recordId, fieldName, (update) => {
+      Y.applyUpdate(doc, update, DOC_CHANNEL_ORIGIN);
+      syncHistoryState();
+    });
+  };
+  const updateCursors = () => {
+    if (!syncEngine) {
+      cursors = [];
+      notify();
+      return;
+    }
+    const awareness = syncEngine.getAwarenessManager();
+    const localClientId = awareness.clientId;
+    const states = awareness.getStates();
+    const fieldCursors = [];
+    for (const [clientId, state] of states) {
+      if (clientId === localClientId) continue;
+      if (!state.cursor) continue;
+      if (state.cursor.collection !== collectionName || state.cursor.recordId !== recordId || state.cursor.field !== fieldName) {
+        continue;
+      }
+      fieldCursors.push({
+        clientId,
+        userName: state.user.name,
+        color: state.user.color,
+        anchor: state.cursor.anchor,
+        head: state.cursor.head
+      });
+    }
+    cursors = fieldCursors;
+    notify();
+  };
+  const subscribeAwareness = () => {
+    awarenessUnsubscribe?.();
+    if (!syncEngine) {
+      cursors = [];
+      notify();
+      return;
+    }
+    const awareness = syncEngine.getAwarenessManager();
+    awarenessUnsubscribe = awareness.on("change", () => {
+      updateCursors();
+    });
+    updateCursors();
+  };
+  const initialize = async () => {
+    ready = false;
+    error = null;
+    notify();
+    try {
+      const record = await collection.findById(recordId);
+      if (disposed) return;
+      doc.transact(() => {
+        const target = doc.getText(TEXT_KEY);
+        target.delete(0, target.length);
+      }, LOAD_ORIGIN);
+      const encoded = encodeRichtextInput(record?.[fieldName]);
+      baseUpdateRef.current = encoded;
+      pendingDeltasRef.current = [];
+      if (encoded) {
+        Y.applyUpdate(doc, encoded, LOAD_ORIGIN);
+      }
+      const channel = syncEngine?.getRichtextDocChannel?.();
+      docChannelActiveRef.current = channel?.shouldUseChannel(encoded?.length ?? 0, useDocChannel) ?? false;
+      ready = true;
+      syncHistoryState();
+      subscribeRecordChanges();
+      subscribeDocChannel();
+      subscribeAwareness();
+      notify();
+    } catch (cause) {
+      if (disposed) return;
+      error = cause instanceof Error ? cause : new Error(String(cause));
+      notify();
+    }
+  };
+  doc.on("update", onDocUpdate);
+  void initialize();
+  return {
+    doc,
+    text,
+    getSnapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    undo() {
+      undoManager.undo();
+      syncHistoryState();
+    },
+    redo() {
+      undoManager.redo();
+      syncHistoryState();
+    },
+    setCursor,
+    clearCursor,
+    setUser(nextUser) {
+      user = nextUser;
+    },
+    destroy() {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      if (persistTimer) {
+        clearTimeout(persistTimer);
+        persistTimer = null;
+      }
+      doc.off("update", onDocUpdate);
+      recordUnsubscribe?.();
+      docChannelUnsubscribe?.();
+      awarenessUnsubscribe?.();
+      clearCursor();
+      undoManager.destroy();
+      baseUpdateRef.current = null;
+      pendingDeltasRef.current = [];
+      docChannelActiveRef.current = false;
+      listeners.clear();
+    }
+  };
+}
+function encodeRichtextInput(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  try {
+    return encodeRichtext(value);
+  } catch {
+    if (typeof value === "string") {
+      const fallbackDoc = new Y.Doc();
+      fallbackDoc.getText(TEXT_KEY).insert(0, value);
+      return Y.encodeStateAsUpdate(fallbackDoc);
+    }
+    throw new Error("Richtext record value must be a string, Uint8Array, ArrayBuffer, or null.");
+  }
+}
+function composeRichtextSnapshot(base, deltas) {
+  const mergedDoc = new Y.Doc();
+  if (base) {
+    Y.applyUpdate(mergedDoc, base);
+  }
+  for (const delta of deltas) {
+    Y.applyUpdate(mergedDoc, delta);
+  }
+  return Y.encodeStateAsUpdate(mergedDoc);
+}
+function updatesEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index++) {
+    if (left[index] !== right[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/richtext/as-rich-text-sync-engine.ts
+function asRichTextSyncEngine(engine) {
+  if (engine == null) {
+    return null;
+  }
+  return engine;
+}
 export {
   AdapterError,
   COMPACTION_BASELINE_META_KEY,
   Collection,
   InvalidStateTransitionError,
   LAST_ACKED_SERVER_VECTOR_META_KEY,
+  OptimisticLockError,
   PersistenceError,
   QueryBuilder,
   QueryError,
+  QueryStore,
+  QueryStoreCache,
   RecordNotFoundError,
   SequenceManager,
   Store,
@@ -2586,14 +3443,18 @@ export {
   TransactionContext,
   WorkerInitError,
   WorkerTimeoutError,
+  asRichTextSyncEngine,
+  assertQueryReady,
   collectOperationsAheadOfServer,
   compactOperationLog,
   computeAckCompactionWatermark,
+  createRichTextController,
   decodeAuditExport,
   decodeRichtext,
   deserializeVersionVectorFromMeta,
   encodeRichtext,
   exportBackup,
+  getSharedQueryStoreCache,
   mergeVersionVectors,
   persistedAuditTraceFromEvent,
   pluralize,