@korajs/store 0.4.0 → 0.6.0

package/dist/index.js

@@ -1,3 +1,31 @@
+import {
+  decodeAuditExport,
+  readAuditExportManifest,
+  verifyAuditExportChecksum
+} from "./chunk-AGN3CIPB.js";
+import {
+  persistedAuditTraceFromEvent
+} from "./chunk-MYSJN3DF.js";
+import {
+  InvalidStateTransitionError,
+  allocateNextSequenceInTransaction,
+  allocateNextSequenceNumber,
+  buildCountQuery,
+  buildInsertQuery,
+  buildLwwSoftDeleteQuery,
+  buildLwwUpdateQuery,
+  buildSelectQuery,
+  buildSoftDeleteQuery,
+  buildUpdateQuery,
+  executeDelete,
+  executeInsert,
+  executeUpdate,
+  isIncomingNewerThanRow,
+  readSequenceNumber,
+  serializeRowVersion,
+  validateStateTransition,
+  validateUpdateStateMachine
+} from "./chunk-7BPETY5Y.js";
 import {
   AdapterError,
   PersistenceError,
@@ -7,452 +35,186 @@ import {
   WorkerInitError,
   WorkerTimeoutError
 } from "./chunk-LAWV6CFH.js";
-
-// src/store/store.ts
 import {
-  HybridLogicalClock as HybridLogicalClock2,
-  createVersionVector,
-  generateUUIDv7 as generateUUIDv73,
-  migrationStepsToSQL
-} from "@korajs/core";
-
-// src/collection/collection.ts
+  exportBackup,
+  readBackupManifest,
+  restoreBackup,
+  verifyBackupChecksum
+} from "./chunk-EZSTD2XC.js";
 import {
-  createOperation,
-  generateUUIDv7,
-  isAtomicOp,
-  resolveAtomicOp,
-  toAtomicOp,
-  validateRecord
-} from "@korajs/core";
+  decodeRichtext,
+  deserializeOperationWithCollection,
+  deserializeRecord,
+  encodeRichtext,
+  richtextStatesEqual,
+  richtextToPlainText,
+  serializeOperation,
+  serializeRecord
+} from "./chunk-56LL4XP6.js";
 
-// src/query/sql-builder.ts
-function buildSelectQuery(descriptor, fields) {
-  const params = [];
-  const parts = [`SELECT * FROM ${descriptor.collection}`];
-  const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
-  const deletedFilter = "_deleted = 0";
-  if (whereClause) {
-    parts.push(`WHERE ${deletedFilter} AND ${whereClause}`);
-  } else {
-    parts.push(`WHERE ${deletedFilter}`);
-  }
-  if (descriptor.orderBy.length > 0) {
-    const orderParts = descriptor.orderBy.map((o) => {
-      validateFieldName(o.field, fields);
-      return `${o.field} ${o.direction.toUpperCase()}`;
-    });
-    parts.push(`ORDER BY ${orderParts.join(", ")}`);
-  }
-  if (descriptor.limit !== void 0) {
-    parts.push(`LIMIT ${descriptor.limit}`);
-  }
-  if (descriptor.offset !== void 0) {
-    parts.push(`OFFSET ${descriptor.offset}`);
-  }
-  return { sql: parts.join(" "), params };
-}
-function buildCountQuery(descriptor, fields) {
-  const params = [];
-  const parts = [`SELECT COUNT(*) as count FROM ${descriptor.collection}`];
-  const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
-  const deletedFilter = "_deleted = 0";
-  if (whereClause) {
-    parts.push(`WHERE ${deletedFilter} AND ${whereClause}`);
-  } else {
-    parts.push(`WHERE ${deletedFilter}`);
-  }
-  return { sql: parts.join(" "), params };
-}
-function buildInsertQuery(collection, record) {
-  const columns = Object.keys(record);
-  const placeholders = columns.map(() => "?");
-  const params = Object.values(record);
-  const sql = `INSERT INTO ${collection} (${columns.join(", ")}) VALUES (${placeholders.join(", ")})`;
-  return { sql, params };
-}
-function buildUpdateQuery(collection, id, changes) {
-  const setClauses = Object.keys(changes).map((col) => `${col} = ?`);
-  const params = [...Object.values(changes), id];
-  const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ?`;
-  return { sql, params };
-}
-function buildSoftDeleteQuery(collection, id, updatedAt) {
-  return {
-    sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ? WHERE id = ?`,
-    params: [updatedAt, id]
-  };
-}
-var VALID_OPERATORS = /* @__PURE__ */ new Set(["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in"]);
-function buildWhereClauseParts(where, fields, params) {
-  const conditions = [];
-  for (const [fieldName, value] of Object.entries(where)) {
-    validateFieldName(fieldName, fields);
-    const descriptor = fields[fieldName];
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      const ops = value;
-      for (const [op, opValue] of Object.entries(ops)) {
-        if (!VALID_OPERATORS.has(op)) {
-          throw new QueryError(`Unknown operator "${op}" on field "${fieldName}"`, {
-            field: fieldName,
-            operator: op,
-            validOperators: [...VALID_OPERATORS]
-          });
-        }
-        conditions.push(buildOperatorCondition(fieldName, op, opValue, descriptor, params));
-      }
-    } else {
-      conditions.push(buildOperatorCondition(fieldName, "$eq", value, descriptor, params));
+// src/compaction/types.ts
+var COMPACTION_BASELINE_META_KEY = "compaction_baseline_at";
+
+// src/compaction/compact-operation-log.ts
+import { HybridLogicalClock, createVersionVector } from "@korajs/core";
+function computeAckCompactionWatermark(serverVector) {
+  const watermark = createVersionVector();
+  for (const [nodeId, seq] of serverVector) {
+    if (seq > 0) {
+      watermark.set(nodeId, seq);
     }
   }
-  if (conditions.length === 0) return null;
-  return conditions.join(" AND ");
+  return watermark;
 }
-function buildOperatorCondition(fieldName, operator, value, descriptor, params) {
-  const sqlValue = descriptor?.kind === "boolean" && typeof value === "boolean" ? value ? 1 : 0 : value;
-  switch (operator) {
-    case "$eq":
-      if (sqlValue === null) {
-        return `${fieldName} IS NULL`;
-      }
-      params.push(sqlValue);
-      return `${fieldName} = ?`;
-    case "$ne":
-      if (sqlValue === null) {
-        return `${fieldName} IS NOT NULL`;
-      }
-      params.push(sqlValue);
-      return `${fieldName} != ?`;
-    case "$gt":
-      params.push(sqlValue);
-      return `${fieldName} > ?`;
-    case "$gte":
-      params.push(sqlValue);
-      return `${fieldName} >= ?`;
-    case "$lt":
-      params.push(sqlValue);
-      return `${fieldName} < ?`;
-    case "$lte":
-      params.push(sqlValue);
-      return `${fieldName} <= ?`;
-    case "$in": {
-      if (!Array.isArray(sqlValue)) {
-        throw new QueryError(`$in operator requires an array value for field "${fieldName}"`, {
-          field: fieldName,
-          received: typeof sqlValue
-        });
+async function compactOperationLog(adapter, schema, strategy, serverVector) {
+  if (strategy.mode === "never") {
+    return { deletedCount: 0, watermark: createVersionVector() };
+  }
+  const watermark = computeAckCompactionWatermark(serverVector);
+  if (watermark.size === 0) {
+    return { deletedCount: 0, watermark };
+  }
+  const ageCutoffWall = strategy.mode === "after-days" ? Date.now() - strategy.days * 24 * 60 * 60 * 1e3 : null;
+  const ageCutoffSerialized = ageCutoffWall !== null ? HybridLogicalClock.serialize({
+    wallTime: ageCutoffWall,
+    logical: 0,
+    nodeId: ""
+  }).slice(0, 15) : null;
+  let deletedCount = 0;
+  const collectionNames = Object.keys(schema.collections);
+  await adapter.transaction(async (tx) => {
+    for (const collectionName of collectionNames) {
+      const table = `_kora_ops_${collectionName}`;
+      for (const [nodeId, maxSeq] of watermark) {
+        if (maxSeq <= 0) continue;
+        const countSql = buildCountSql(table, ageCutoffSerialized !== null);
+        const countParams = ageCutoffSerialized !== null ? [nodeId, maxSeq, ageCutoffSerialized] : [nodeId, maxSeq];
+        const countRows = await tx.query(countSql, countParams);
+        deletedCount += countRows[0]?.count ?? 0;
+        const deleteSql = buildDeleteSql(table, ageCutoffSerialized !== null);
+        await tx.execute(deleteSql, countParams);
       }
-      const placeholders = sqlValue.map(() => "?");
-      for (const item of sqlValue) {
-        params.push(
-          descriptor?.kind === "boolean" && typeof item === "boolean" ? item ? 1 : 0 : item
-        );
-      }
-      return `${fieldName} IN (${placeholders.join(", ")})`;
     }
-    default:
-      throw new QueryError(`Unknown operator "${operator}"`, { operator });
-  }
-}
-function validateFieldName(fieldName, fields) {
-  const allowedFields = /* @__PURE__ */ new Set([
-    ...Object.keys(fields),
-    "id",
-    "createdAt",
-    "updatedAt",
-    "_created_at",
-    "_updated_at"
-  ]);
-  if (!allowedFields.has(fieldName)) {
-    throw new QueryError(
-      `Unknown field "${fieldName}" in query. Available fields: ${[...allowedFields].join(", ")}`,
-      { field: fieldName }
-    );
-  }
+    await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+      COMPACTION_BASELINE_META_KEY,
+      String(Date.now())
+    ]);
+  });
+  return { deletedCount, watermark };
 }
-
-// src/serialization/serializer.ts
-import { HybridLogicalClock } from "@korajs/core";
-
-// src/serialization/richtext-serializer.ts
-import * as Y from "yjs";
-var TEXT_KEY = "content";
-function encodeRichtext(value) {
-  if (value === null || value === void 0) {
-    return null;
-  }
-  if (typeof value === "string") {
-    const doc = new Y.Doc();
-    doc.getText(TEXT_KEY).insert(0, value);
-    return Y.encodeStateAsUpdate(doc);
-  }
-  if (value instanceof Uint8Array) {
-    return value;
+function buildCountSql(table, withAge) {
+  if (withAge) {
+    return `SELECT COUNT(*) as count FROM ${table} WHERE node_id = ? AND sequence_number <= ? AND SUBSTR(timestamp, 1, 15) < ?`;
   }
-  if (value instanceof ArrayBuffer) {
-    return new Uint8Array(value);
-  }
-  throw new Error("Richtext value must be a string, Uint8Array, ArrayBuffer, null, or undefined.");
+  return `SELECT COUNT(*) as count FROM ${table} WHERE node_id = ? AND sequence_number <= ?`;
 }
-function decodeRichtext(value) {
-  if (value === null || value === void 0) {
-    return null;
-  }
-  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
-    return new Uint8Array(value);
+function buildDeleteSql(table, withAge) {
+  if (withAge) {
+    return `DELETE FROM ${table} WHERE node_id = ? AND sequence_number <= ? AND SUBSTR(timestamp, 1, 15) < ?`;
   }
-  if (value instanceof Uint8Array) {
-    return value;
-  }
-  if (value instanceof ArrayBuffer) {
-    return new Uint8Array(value);
-  }
-  throw new Error(
-    "Richtext storage value must be Uint8Array, ArrayBuffer, Buffer, null, or undefined."
-  );
-}
-function richtextToPlainText(value) {
-  const encoded = encodeRichtext(value);
-  if (!encoded) return "";
-  const doc = new Y.Doc();
-  Y.applyUpdate(doc, encoded);
-  return doc.getText(TEXT_KEY).toString();
+  return `DELETE FROM ${table} WHERE node_id = ? AND sequence_number <= ?`;
 }
 
-// src/serialization/serializer.ts
-function serializeRecord(data, fields) {
-  const result = {};
-  for (const [key, value] of Object.entries(data)) {
-    const descriptor = fields[key];
-    if (!descriptor) {
-      result[key] = value;
-      continue;
-    }
-    result[key] = serializeValue(value, descriptor);
-  }
-  return result;
+// src/sync/sync-state.ts
+import { createVersionVector as createVersionVector2 } from "@korajs/core";
+var LAST_ACKED_SERVER_VECTOR_META_KEY = "last_acked_server_vector";
+var DELTA_CURSOR_META_KEY = "delta_cursor";
+function serializeVersionVectorToMeta(vector) {
+  const record = {};
+  for (const [nodeId, seq] of vector) {
+    record[nodeId] = seq;
+  }
+  return JSON.stringify(record);
 }
-function deserializeRecord(row, fields) {
-  const result = {
-    id: row.id,
-    createdAt: row._created_at,
-    updatedAt: row._updated_at
-  };
-  for (const [key, descriptor] of Object.entries(fields)) {
-    const rawValue = row[key];
-    if (rawValue === void 0 || rawValue === null) {
-      result[key] = rawValue ?? null;
-      continue;
+function deserializeVersionVectorFromMeta(value) {
+  const parsed = JSON.parse(value);
+  const vector = createVersionVector2();
+  for (const [nodeId, seq] of Object.entries(parsed)) {
+    if (typeof seq === "number" && seq >= 0) {
+      vector.set(nodeId, seq);
     }
-    result[key] = deserializeValue(rawValue, descriptor);
   }
-  return result;
+  return vector;
 }
-var ATOMIC_OPS_KEY = "__kora_atomic_ops__";
-var TX_ID_KEY = "__kora_tx_id__";
-var MUTATION_NAME_KEY = "__kora_mutation__";
-function serializeOperation(op) {
-  const hasMetadata = op.transactionId !== void 0 || op.mutationName !== void 0;
-  let dataPayload = null;
-  if (op.data) {
-    dataPayload = { ...op.data };
-    if (op.atomicOps !== void 0 && Object.keys(op.atomicOps).length > 0) {
-      dataPayload[ATOMIC_OPS_KEY] = op.atomicOps;
-    }
-    if (op.transactionId !== void 0) {
-      dataPayload[TX_ID_KEY] = op.transactionId;
-    }
-    if (op.mutationName !== void 0) {
-      dataPayload[MUTATION_NAME_KEY] = op.mutationName;
-    }
-  } else if (hasMetadata) {
-    dataPayload = {};
-    if (op.transactionId !== void 0) {
-      dataPayload[TX_ID_KEY] = op.transactionId;
-    }
-    if (op.mutationName !== void 0) {
-      dataPayload[MUTATION_NAME_KEY] = op.mutationName;
-    }
+function mergeVersionVectors(a, b) {
+  const merged = new Map(a);
+  for (const [nodeId, seq] of b) {
+    merged.set(nodeId, Math.max(merged.get(nodeId) ?? 0, seq));
   }
-  return {
-    id: op.id,
-    node_id: op.nodeId,
-    type: op.type,
-    record_id: op.recordId,
-    data: dataPayload ? JSON.stringify(dataPayload) : null,
-    previous_data: op.previousData ? JSON.stringify(op.previousData) : null,
-    timestamp: HybridLogicalClock.serialize(op.timestamp),
-    sequence_number: op.sequenceNumber,
-    causal_deps: JSON.stringify(op.causalDeps),
-    schema_version: op.schemaVersion
-  };
+  return merged;
 }
-function deserializeOperation(row) {
-  let data = null;
-  let atomicOps;
-  let transactionId;
-  let mutationName;
-  if (row.data) {
-    const parsed = JSON.parse(row.data);
-    if (ATOMIC_OPS_KEY in parsed) {
-      atomicOps = parsed[ATOMIC_OPS_KEY];
-    }
-    if (TX_ID_KEY in parsed) {
-      transactionId = parsed[TX_ID_KEY];
+async function collectOperationsAheadOfServer(localVector, serverVector, fetchRange) {
+  const missing = [];
+  for (const [nodeId, localSeq] of localVector) {
+    const serverSeq = serverVector.get(nodeId) ?? 0;
+    if (localSeq > serverSeq) {
+      const ops = await fetchRange(nodeId, serverSeq + 1, localSeq);
+      missing.push(...ops);
     }
-    if (MUTATION_NAME_KEY in parsed) {
-      mutationName = parsed[MUTATION_NAME_KEY];
-    }
-    const { [ATOMIC_OPS_KEY]: _a, [TX_ID_KEY]: _t, [MUTATION_NAME_KEY]: _m, ...rest } = parsed;
-    data = Object.keys(rest).length > 0 ? rest : null;
   }
-  return {
-    id: row.id,
-    nodeId: row.node_id,
-    type: row.type,
-    collection: "",
-    // Collection name is derived from the table name by the caller
-    recordId: row.record_id,
-    data,
-    previousData: row.previous_data ? JSON.parse(row.previous_data) : null,
-    timestamp: HybridLogicalClock.deserialize(row.timestamp),
-    sequenceNumber: row.sequence_number,
-    causalDeps: JSON.parse(row.causal_deps),
-    schemaVersion: row.schema_version,
-    ...atomicOps !== void 0 ? { atomicOps } : {},
-    ...transactionId !== void 0 ? { transactionId } : {},
-    ...mutationName !== void 0 ? { mutationName } : {}
-  };
-}
-function deserializeOperationWithCollection(row, collection) {
-  const op = deserializeOperation(row);
-  return { ...op, collection };
+  missing.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
+  return missing;
 }
-function serializeValue(value, descriptor) {
-  if (value === null || value === void 0) {
-    return null;
+async function loadLastAckedServerVector(adapter) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    LAST_ACKED_SERVER_VECTOR_META_KEY
+  ]);
+  const row = rows[0];
+  if (!row?.value) {
+    return createVersionVector2();
   }
-  switch (descriptor.kind) {
-    case "boolean":
-      return value ? 1 : 0;
-    case "array":
-      return JSON.stringify(value);
-    case "richtext":
-      return encodeRichtext(value);
-    default:
-      return value;
+  try {
+    return deserializeVersionVectorFromMeta(row.value);
+  } catch {
+    return createVersionVector2();
   }
 }
-function deserializeValue(value, descriptor) {
-  switch (descriptor.kind) {
-    case "boolean":
-      return value === 1 || value === true;
-    case "array":
-      if (typeof value === "string") {
-        return JSON.parse(value);
-      }
-      return value;
-    case "richtext":
-      return decodeRichtext(value);
-    default:
-      return value;
-  }
+async function saveLastAckedServerVector(adapter, vector) {
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    LAST_ACKED_SERVER_VECTOR_META_KEY,
+    serializeVersionVectorToMeta(vector)
+  ]);
 }
-
-// src/state-machine/state-validator.ts
-import { KoraError, validateTransition } from "@korajs/core";
-var InvalidStateTransitionError = class extends KoraError {
-  constructor(collection, recordId, field, fromState, toState, allowedStates) {
-    super(
-      `Invalid state transition in collection "${collection}": cannot transition field "${field}" from "${fromState}" to "${toState}". Allowed transitions from "${fromState}": ${allowedStates.length > 0 ? allowedStates.join(", ") : "(none -- terminal state)"}`,
-      "INVALID_STATE_TRANSITION",
-      { collection, recordId, field, fromState, toState, allowedStates }
-    );
-    this.collection = collection;
-    this.recordId = recordId;
-    this.field = field;
-    this.fromState = fromState;
-    this.toState = toState;
-    this.allowedStates = allowedStates;
-    this.name = "InvalidStateTransitionError";
-  }
-  collection;
-  recordId;
-  field;
-  fromState;
-  toState;
-  allowedStates;
-};
-function validateStateTransition(collectionName, recordId, stateMachine, currentState, newState) {
-  if (currentState === null) {
-    return { valid: true, allowedStates: [] };
-  }
-  if (currentState === newState) {
-    return { valid: true, allowedStates: stateMachine.transitions[currentState] ?? [] };
-  }
-  const constraint = {
-    field: stateMachine.field,
-    collection: collectionName,
-    transitions: stateMachine.transitions
-  };
-  const transitionResult = validateTransition(constraint, currentState, newState);
-  if (transitionResult.valid) {
-    return { valid: true, allowedStates: transitionResult.allowedTargets };
-  }
-  const allowedStates = transitionResult.allowedTargets;
-  if (stateMachine.onInvalidTransition === "reject") {
-    throw new InvalidStateTransitionError(
-      collectionName,
-      recordId,
-      stateMachine.field,
-      currentState,
-      newState,
-      allowedStates
-    );
-  }
-  return { valid: false, allowedStates };
+async function loadDeltaCursor(adapter) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    DELTA_CURSOR_META_KEY
+  ]);
+  return rows[0]?.value ?? null;
 }
-function validateUpdateStateMachine(collectionName, recordId, collectionDef, currentRecord, updateData) {
-  const stateMachine = collectionDef.stateMachine;
-  if (stateMachine === void 0) {
-    return updateData;
-  }
-  const stateField = stateMachine.field;
-  if (!(stateField in updateData)) {
-    return updateData;
-  }
-  const currentState = currentRecord[stateField];
-  const newState = updateData[stateField];
-  if (typeof currentState !== "string" || typeof newState !== "string") {
-    return updateData;
-  }
-  const result = validateStateTransition(
-    collectionName,
-    recordId,
-    stateMachine,
-    currentState,
-    newState
-  );
-  if (result.valid) {
-    return updateData;
-  }
-  const filtered = { ...updateData };
-  delete filtered[stateField];
-  return filtered;
+async function saveDeltaCursor(adapter, cursor) {
+  if (cursor === null) {
+    await adapter.execute("DELETE FROM _kora_meta WHERE key = ?", [DELTA_CURSOR_META_KEY]);
+    return;
+  }
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    DELTA_CURSOR_META_KEY,
+    cursor
+  ]);
 }
 
+// src/store/store.ts
+import {
+  CausalTracker,
+  HybridLogicalClock as HybridLogicalClock2,
+  createVersionVector as createVersionVector3,
+  generateUUIDv7 as generateUUIDv73,
+  migrationStepsToSQL
+} from "@korajs/core";
+
 // src/collection/collection.ts
 var Collection = class {
-  constructor(name, definition, schema, adapter, clock, nodeId, getSequenceNumber, onMutation, relationEnforcer) {
+  constructor(name, definition, schema, adapter, clock, nodeId, allocateSequenceNumber, onMutation, relationEnforcer, mutationHandler, causalTracker) {
     this.name = name;
     this.definition = definition;
     this.schema = schema;
     this.adapter = adapter;
     this.clock = clock;
     this.nodeId = nodeId;
-    this.getSequenceNumber = getSequenceNumber;
+    this.allocateSequenceNumber = allocateSequenceNumber;
     this.onMutation = onMutation;
-    this.relationEnforcer = relationEnforcer ?? null;
+    this.relationEnforcer = relationEnforcer;
+    this.mutationHandler = mutationHandler;
+    this.causalTracker = causalTracker;
   }
   name;
   definition;
@@ -460,72 +222,32 @@ var Collection = class {
   adapter;
   clock;
   nodeId;
-  getSequenceNumber;
+  allocateSequenceNumber;
   onMutation;
   relationEnforcer;
-  /**
-   * Insert a new record into the collection.
-   * Generates a UUID v7 for the id, validates data, and persists atomically.
-   *
-   * @param data - The record data (auto fields and defaults are applied automatically)
-   * @returns The inserted record with id, createdAt, updatedAt
-   */
-  async insert(data) {
-    const validated = validateRecord(this.name, this.definition, data, "insert");
-    const recordId = generateUUIDv7();
-    const now = Date.now();
-    for (const [fieldName, descriptor] of Object.entries(this.definition.fields)) {
-      if (descriptor.auto && descriptor.kind === "timestamp") {
-        validated[fieldName] = now;
-      }
-    }
-    const sequenceNumber = this.getSequenceNumber();
-    const operation = await createOperation(
-      {
-        nodeId: this.nodeId,
-        type: "insert",
-        collection: this.name,
-        recordId,
-        data: { ...validated },
-        previousData: null,
-        sequenceNumber,
-        causalDeps: [],
-        schemaVersion: this.schema.version
-      },
-      this.clock
-    );
-    const serializedData = serializeRecord(validated, this.definition.fields);
-    const record = {
-      id: recordId,
-      ...serializedData,
-      _created_at: now,
-      _updated_at: now
-    };
-    const insertQuery = buildInsertQuery(this.name, record);
-    const opRow = serializeOperation(operation);
-    const opInsert = buildInsertQuery(
-      `_kora_ops_${this.name}`,
-      opRow
-    );
-    await this.adapter.transaction(async (tx) => {
-      await tx.execute(insertQuery.sql, insertQuery.params);
-      await tx.execute(opInsert.sql, opInsert.params);
-      await tx.execute(
-        "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-        [this.nodeId, sequenceNumber]
-      );
-    });
-    this.onMutation(this.name, operation);
+  mutationHandler;
+  causalTracker;
+  mutationContext() {
     return {
-      id: recordId,
-      ...validated,
-      createdAt: now,
-      updatedAt: now
+      collection: this.name,
+      definition: this.definition,
+      schema: this.schema,
+      adapter: this.adapter,
+      clock: this.clock,
+      nodeId: this.nodeId,
+      allocateSequenceNumber: this.allocateSequenceNumber,
+      onMutation: this.onMutation,
+      relationEnforcer: this.relationEnforcer,
+      causalTracker: this.causalTracker,
+      inTransaction: false
     };
   }
-  /**
-   * Find a record by its ID. Returns null if not found or soft-deleted.
-   */
+  async insert(data) {
+    if (this.mutationHandler) {
+      return this.mutationHandler.insert(this.name, data);
+    }
+    return executeInsert(this.mutationContext(), data);
+  }
   async findById(id) {
     const rows = await this.adapter.query(
       `SELECT * FROM ${this.name} WHERE id = ? AND _deleted = 0`,
@@ -535,173 +257,29 @@ var Collection = class {
     if (!row) return null;
     return deserializeRecord(row, this.definition.fields);
   }
-  /**
-   * Update an existing record. Only the provided fields are changed.
-   *
-   * @param id - The record ID to update
-   * @param data - Partial data with only the fields to change
-   * @returns The updated record
-   * @throws {RecordNotFoundError} If the record doesn't exist or is deleted
-   */
   async update(id, data) {
-    const currentRows = await this.adapter.query(
-      `SELECT * FROM ${this.name} WHERE id = ? AND _deleted = 0`,
-      [id]
-    );
-    const currentRow = currentRows[0];
-    if (!currentRow) {
-      throw new RecordNotFoundError(this.name, id);
-    }
-    let validated = validateRecord(this.name, this.definition, data, "update");
-    const now = Date.now();
-    const currentRecord = deserializeRecord(currentRow, this.definition.fields);
-    validated = validateUpdateStateMachine(
-      this.name,
-      id,
-      this.definition,
-      currentRecord,
-      validated
-    );
-    if (Object.keys(validated).length === 0) {
-      const fullRecord = await this.findById(id);
-      if (!fullRecord) {
-        throw new RecordNotFoundError(this.name, id);
-      }
-      return fullRecord;
-    }
-    const previousData = {};
-    const resolvedData = {};
-    const atomicOps = {};
-    for (const key of Object.keys(validated)) {
-      const value = validated[key];
-      previousData[key] = currentRecord[key];
-      if (isAtomicOp(value)) {
-        resolvedData[key] = resolveAtomicOp(currentRecord[key], value);
-        atomicOps[key] = toAtomicOp(value);
-      } else {
-        resolvedData[key] = value;
-      }
-    }
-    const hasAtomicOps = Object.keys(atomicOps).length > 0;
-    const sequenceNumber = this.getSequenceNumber();
-    const operation = await createOperation(
-      {
-        nodeId: this.nodeId,
-        type: "update",
-        collection: this.name,
-        recordId: id,
-        data: { ...resolvedData },
-        previousData,
-        sequenceNumber,
-        causalDeps: [],
-        schemaVersion: this.schema.version,
-        ...hasAtomicOps ? { atomicOps } : {}
-      },
-      this.clock
-    );
-    const serializedChanges = serializeRecord(resolvedData, this.definition.fields);
-    const updateQuery = buildUpdateQuery(this.name, id, {
-      ...serializedChanges,
-      _updated_at: now
-    });
-    const opRow = serializeOperation(operation);
-    const opInsert = buildInsertQuery(
-      `_kora_ops_${this.name}`,
-      opRow
-    );
-    await this.adapter.transaction(async (tx) => {
-      await tx.execute(updateQuery.sql, updateQuery.params);
-      await tx.execute(opInsert.sql, opInsert.params);
-      await tx.execute(
-        "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-        [this.nodeId, sequenceNumber]
-      );
-    });
-    this.onMutation(this.name, operation);
-    const updatedRow = await this.findById(id);
-    if (!updatedRow) {
-      throw new RecordNotFoundError(this.name, id);
+    if (this.mutationHandler) {
+      return this.mutationHandler.update(this.name, id, data);
     }
-    return updatedRow;
+    return executeUpdate(this.mutationContext(), id, data);
   }
-  /**
-   * Soft-delete a record by its ID.
-   *
-   * When a RelationEnforcer is configured, referential integrity policies
-   * are enforced within the same transaction:
-   * - **cascade**: Recursively deletes all referencing records
-   * - **set-null**: Sets foreign keys to null on referencing records
-   * - **restrict**: Throws ReferentialIntegrityError if references exist
-   * - **no-action**: Does nothing (dangling references are left)
-   *
-   * All cascaded operations are created atomically within the same transaction
-   * and share causal dependencies with the original delete.
-   *
-   * @param id - The record ID to delete
-   * @throws {RecordNotFoundError} If the record doesn't exist or is already deleted
-   * @throws {ReferentialIntegrityError} If a 'restrict' policy is violated
-   */
   async delete(id) {
-    const currentRows = await this.adapter.query(
-      `SELECT * FROM ${this.name} WHERE id = ? AND _deleted = 0`,
-      [id]
-    );
-    if (!currentRows[0]) {
-      throw new RecordNotFoundError(this.name, id);
-    }
-    const now = Date.now();
-    const sequenceNumber = this.getSequenceNumber();
-    const operation = await createOperation(
-      {
-        nodeId: this.nodeId,
-        type: "delete",
-        collection: this.name,
-        recordId: id,
-        data: null,
-        previousData: null,
-        sequenceNumber,
-        causalDeps: [],
-        schemaVersion: this.schema.version
-      },
-      this.clock
-    );
-    const deleteQuery = buildSoftDeleteQuery(this.name, id, now);
-    const opRow = serializeOperation(operation);
-    const opInsert = buildInsertQuery(
-      `_kora_ops_${this.name}`,
-      opRow
-    );
-    const cascadedOps = [];
-    await this.adapter.transaction(async (tx) => {
-      if (this.relationEnforcer) {
-        const enforcementResult = await this.relationEnforcer.enforceDelete(
-          this.name,
-          id,
-          tx,
-          [operation.id]
-        );
-        cascadedOps.push(...enforcementResult.operations);
-      }
-      await tx.execute(deleteQuery.sql, deleteQuery.params);
-      await tx.execute(opInsert.sql, opInsert.params);
-      await tx.execute(
-        "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-        [this.nodeId, sequenceNumber]
-      );
-    });
-    this.onMutation(this.name, operation);
-    for (const cascadedOp of cascadedOps) {
-      this.onMutation(cascadedOp.collection, cascadedOp);
+    if (this.mutationHandler) {
+      await this.mutationHandler.delete(this.name, id);
+      return;
     }
+    await executeDelete(this.mutationContext(), id);
   }
-  /** Get the collection name */
   getName() {
     return this.name;
   }
-  /** Get the collection definition */
   getDefinition() {
     return this.definition;
   }
+  /** Replace the mutation handler (e.g. after ApplyPipeline is wired in createApp). */
+  setMutationHandler(handler) {
+    this.mutationHandler = handler;
+  }
 };
 
 // src/query/pluralize.ts
@@ -998,7 +576,7 @@ var QueryError2 = class extends Error {
 };
 
 // src/relations/relation-enforcer.ts
-import { KoraError as KoraError2, createOperation as createOperation2 } from "@korajs/core";
+import { KoraError, createOperation } from "@korajs/core";
 
 // src/relations/relation-lookup.ts
 function buildRelationLookup(schema) {
@@ -1022,7 +600,7 @@ function getIncomingRelations(lookup, collection) {
 }
 
 // src/relations/relation-enforcer.ts
-var ReferentialIntegrityError = class extends KoraError2 {
+var ReferentialIntegrityError = class extends KoraError {
   constructor(collection, recordId, referencingCollection, relationName, referencingCount) {
     super(
       `Cannot delete record "${recordId}" from "${collection}": ${referencingCount} record(s) in "${referencingCollection}" reference it via relation "${relationName}" with onDelete: 'restrict'. Delete or reassign the referencing records first.`,
@@ -1044,13 +622,11 @@ var RelationEnforcer = class {
   adapter;
   clock;
   nodeId;
-  getSequenceNumber;
   constructor(config) {
     this.schema = config.schema;
     this.adapter = config.adapter;
     this.clock = config.clock;
     this.nodeId = config.nodeId;
-    this.getSequenceNumber = config.getSequenceNumber;
     this.lookup = buildRelationLookup(config.schema);
   }
   /**
@@ -1112,8 +688,8 @@ var RelationEnforcer = class {
     const operations = [];
     for (const row of referencingRows) {
       const now = Date.now();
-      const sequenceNumber = this.getSequenceNumber();
-      const operation = await createOperation2(
+      const sequenceNumber = await allocateNextSequenceInTransaction(tx, this.nodeId);
+      const operation = await createOperation(
         {
           nodeId: this.nodeId,
           type: "delete",
@@ -1129,16 +705,11 @@ var RelationEnforcer = class {
       );
       const deleteQuery = buildSoftDeleteQuery(sourceCollection, row.id, now);
       await tx.execute(deleteQuery.sql, deleteQuery.params);
-      const opRow = serializeOperation(operation);
       const opInsert = buildInsertQuery(
         `_kora_ops_${sourceCollection}`,
-        opRow
+        serializeOperation(operation)
       );
       await tx.execute(opInsert.sql, opInsert.params);
-      await tx.execute(
-        "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-        [this.nodeId, sequenceNumber]
-      );
       operations.push(operation);
       const cascadeResult = await this.enforceDelete(sourceCollection, row.id, tx, [operation.id]);
       operations.push(...cascadeResult.operations);
@@ -1164,10 +735,10 @@ var RelationEnforcer = class {
     const operations = [];
     for (const row of referencingRows) {
       const now = Date.now();
-      const sequenceNumber = this.getSequenceNumber();
+      const sequenceNumber = await allocateNextSequenceInTransaction(tx, this.nodeId);
       const updateData = { [foreignKeyField]: null };
       const previousData = { [foreignKeyField]: deletedRecordId };
-      const operation = await createOperation2(
+      const operation = await createOperation(
         {
           nodeId: this.nodeId,
           type: "update",
@@ -1193,10 +764,6 @@ var RelationEnforcer = class {
         opRow
       );
       await tx.execute(opInsert.sql, opInsert.params);
-      await tx.execute(
-        "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-        [this.nodeId, sequenceNumber]
-      );
       operations.push(operation);
     }
     return operations;
@@ -1231,20 +798,184 @@ var RelationEnforcer = class {
   }
 };
 
-// src/sequences/sequence-manager.ts
-import { defaultSequenceFormat, formatSequenceValue } from "@korajs/core";
-var SequenceManager = class {
-  adapter;
-  nodeId;
-  constructor(adapter, nodeId) {
-    this.adapter = adapter;
-    this.nodeId = nodeId;
+// src/replay/replay-to.ts
+import { OperationError } from "@korajs/core";
+import { topologicalSort } from "@korajs/core/internal";
+function collectCausalClosure(allOps, targetOperationId) {
+  const opMap = /* @__PURE__ */ new Map();
+  for (const op of allOps) {
+    opMap.set(op.id, op);
+  }
+  const target = opMap.get(targetOperationId);
+  if (!target) {
+    throw new OperationError(
+      `Operation "${targetOperationId}" not found in the local operation log`,
+      {
+        operationId: targetOperationId
+      }
+    );
   }
-  /**
-   * Get the next value in a sequence, atomically incrementing the counter.
-   *
-   * @param name - The sequence name (e.g., 'receipt', 'invoice')
-   * @param config - Optional configuration for scope, format, and starting value
+  const included = /* @__PURE__ */ new Set();
+  const stack = [targetOperationId];
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (id === void 0 || included.has(id)) {
+      continue;
+    }
+    included.add(id);
+    const op = opMap.get(id);
+    if (!op) {
+      continue;
+    }
+    for (const depId of op.causalDeps) {
+      if (opMap.has(depId)) {
+        stack.push(depId);
+      }
+    }
+  }
+  const subset = allOps.filter((op) => included.has(op.id));
+  return topologicalSort(subset);
+}
+function buildReplaySnapshot(schema, allOps, targetOperationId) {
+  const operationsApplied = collectCausalClosure(allOps, targetOperationId);
+  const targetOperation = operationsApplied.find((op) => op.id === targetOperationId);
+  if (!targetOperation) {
+    throw new OperationError(`Operation "${targetOperationId}" not found after causal sort`, {
+      operationId: targetOperationId
+    });
+  }
+  const memory = /* @__PURE__ */ new Map();
+  for (const op of operationsApplied) {
+    applyOperationToMemory(memory, op, schema);
+  }
+  const collections = materializeCollections(schema, memory);
+  return {
+    targetOperation,
+    operationsApplied,
+    collections,
+    findRecord(collection, recordId) {
+      const colMap = memory.get(collection);
+      const record = colMap?.get(recordId);
+      if (!record || record.deleted) {
+        return null;
+      }
+      const definition = schema.collections[collection];
+      if (!definition) {
+        return null;
+      }
+      return toCollectionRecord(record, definition);
+    }
+  };
+}
+function applyOperationToMemory(state, op, schema) {
+  const definition = schema.collections[op.collection];
+  if (!definition) {
+    return;
+  }
+  let colMap = state.get(op.collection);
+  if (!colMap) {
+    colMap = /* @__PURE__ */ new Map();
+    state.set(op.collection, colMap);
+  }
+  const wallTime = op.timestamp.wallTime;
+  switch (op.type) {
+    case "insert": {
+      if (!op.data) {
+        return;
+      }
+      colMap.set(op.recordId, {
+        id: op.recordId,
+        fields: { ...op.data },
+        deleted: false,
+        createdAt: wallTime,
+        updatedAt: wallTime
+      });
+      break;
+    }
+    case "update": {
+      if (!op.data) {
+        return;
+      }
+      const existing = colMap.get(op.recordId);
+      if (existing && !existing.deleted) {
+        existing.fields = { ...existing.fields, ...op.data };
+        existing.updatedAt = wallTime;
+        break;
+      }
+      if (existing?.deleted) {
+        return;
+      }
+      colMap.set(op.recordId, {
+        id: op.recordId,
+        fields: { ...op.data },
+        deleted: false,
+        createdAt: wallTime,
+        updatedAt: wallTime
+      });
+      break;
+    }
+    case "delete": {
+      const existing = colMap.get(op.recordId);
+      if (existing) {
+        existing.deleted = true;
+        existing.updatedAt = wallTime;
+        return;
+      }
+      colMap.set(op.recordId, {
+        id: op.recordId,
+        fields: {},
+        deleted: true,
+        createdAt: wallTime,
+        updatedAt: wallTime
+      });
+      break;
+    }
+  }
+}
+function materializeCollections(schema, memory) {
+  const collections = {};
+  for (const [collectionName, definition] of Object.entries(schema.collections)) {
+    const colMap = memory.get(collectionName);
+    const records = [];
+    if (colMap) {
+      for (const record of colMap.values()) {
+        if (!record.deleted) {
+          records.push(toCollectionRecord(record, definition));
+        }
+      }
+    }
+    collections[collectionName] = records;
+  }
+  return collections;
+}
+function toCollectionRecord(record, definition) {
+  const result = {
+    id: record.id,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  };
+  for (const [fieldName] of Object.entries(definition.fields)) {
+    if (fieldName in record.fields) {
+      result[fieldName] = record.fields[fieldName];
+    }
+  }
+  return result;
+}
+
+// src/sequences/sequence-manager.ts
+import { defaultSequenceFormat, formatSequenceValue } from "@korajs/core";
+var SequenceManager = class {
+  adapter;
+  nodeId;
+  constructor(adapter, nodeId) {
+    this.adapter = adapter;
+    this.nodeId = nodeId;
+  }
+  /**
+   * Get the next value in a sequence, atomically incrementing the counter.
+   *
+   * @param name - The sequence name (e.g., 'receipt', 'invoice')
+   * @param config - Optional configuration for scope, format, and starting value
    * @returns The formatted sequence value
    */
   async next(name, config) {
@@ -1474,6 +1205,7 @@ var SubscriptionManager = class {
   subscriptions = /* @__PURE__ */ new Map();
   pendingCollections = /* @__PURE__ */ new Set();
   flushScheduled = false;
+  onQuerySubscribed;
   // Bloom filter state
   bloomFilter = null;
   bloomDirty = false;
@@ -1490,6 +1222,7 @@ var SubscriptionManager = class {
     this.bloomThreshold = options?.bloomThreshold ?? DEFAULT_BLOOM_THRESHOLD;
     this.bloomExpectedItems = options?.bloomExpectedItems ?? DEFAULT_BLOOM_EXPECTED_ITEMS;
     this.bloomFalsePositiveRate = options?.bloomFalsePositiveRate ?? DEFAULT_BLOOM_FALSE_POSITIVE_RATE;
+    this.onQuerySubscribed = options?.onQuerySubscribed;
   }
   /**
    * Register a new subscription.
@@ -1510,9 +1243,11 @@ var SubscriptionManager = class {
     };
     this.subscriptions.set(id, subscription);
     this.bloomDirty = true;
+    const externalCleanup = this.onQuerySubscribed?.(descriptor);
     return () => {
       this.subscriptions.delete(id);
       this.bloomDirty = true;
+      externalCleanup?.();
     };
   }
   /**
@@ -1533,6 +1268,7 @@ var SubscriptionManager = class {
     };
     this.subscriptions.set(id, subscription);
     this.bloomDirty = true;
+    const externalCleanup = this.onQuerySubscribed?.(descriptor);
     executeFn().then((results) => {
       if (this.subscriptions.has(id)) {
         subscription.lastResults = results;
@@ -1542,6 +1278,7 @@ var SubscriptionManager = class {
     return () => {
       this.subscriptions.delete(id);
       this.bloomDirty = true;
+      externalCleanup?.();
     };
   }
   /**
@@ -1677,10 +1414,7 @@ var SubscriptionManager = class {
    * any included collection dependencies.
    */
   rebuildBloomFilter() {
-    const filter = new SubscriptionBloomFilter(
-      this.bloomExpectedItems,
-      this.bloomFalsePositiveRate
-    );
+    const filter = new SubscriptionBloomFilter(this.bloomExpectedItems, this.bloomFalsePositiveRate);
     for (const sub of this.subscriptions.values()) {
       filter.add(sub.descriptor.collection);
       if (sub.descriptor.includeCollections) {
@@ -1700,24 +1434,38 @@ var SubscriptionManager = class {
     });
   }
   /**
-   * Compare two result sets. Uses length check + JSON comparison as pragmatic approach.
-   * Sufficient for typical query results. Can be optimized to id-based diffing if profiling shows need.
+   * Compare two result sets. Uses ID-based comparison first (same length, same IDs),
+   * then deep comparison of remaining fields when IDs match.
+   * Avoids JSON.stringify which is O(n) and fragile to field ordering differences.
    */
   resultsEqual(prev, next) {
     if (prev.length !== next.length) return false;
     if (prev.length === 0) return true;
-    return JSON.stringify(prev) === JSON.stringify(next);
+    for (let i = 0; i < prev.length; i++) {
+      if (prev[i]?.id !== next[i]?.id) return false;
+    }
+    for (let i = 0; i < prev.length; i++) {
+      const a = prev[i];
+      const b = next[i];
+      const keysA = Object.keys(a);
+      const keysB = Object.keys(b);
+      if (keysA.length !== keysB.length) return false;
+      for (const key of keysA) {
+        if (a[key] !== b[key]) return false;
+      }
+    }
+    return true;
   }
 };
 
 // src/transaction/transaction-context.ts
 import {
-  createOperation as createOperation3,
-  generateUUIDv7 as generateUUIDv72,
-  isAtomicOp as isAtomicOp2,
-  resolveAtomicOp as resolveAtomicOp2,
-  toAtomicOp as toAtomicOp2,
-  validateRecord as validateRecord2
+  createOperation as createOperation2,
+  generateUUIDv7,
+  isAtomicOp,
+  resolveAtomicOp,
+  toAtomicOp,
+  validateRecord
 } from "@korajs/core";
 var TransactionContext = class {
   transactionId;
@@ -1728,7 +1476,7 @@ var TransactionContext = class {
   config;
   constructor(config) {
     this.config = config;
-    this.transactionId = generateUUIDv72();
+    this.transactionId = generateUUIDv7();
   }
   /**
    * Set a human-readable mutation name for this transaction.
@@ -1775,16 +1523,48 @@ var TransactionContext = class {
     if (this.buffer.length === 0) {
       return { operations: [], affectedCollections: /* @__PURE__ */ new Set() };
     }
+    const handler = this.config.localMutationHandler;
+    if (handler?.commitTransaction) {
+      return handler.commitTransaction({
+        entries: this.buffer.map((entry) => ({
+          operation: entry.operation,
+          commands: entry.commands,
+          collection: entry.collection
+        })),
+        transactionId: this.transactionId,
+        ...this.mutationName !== void 0 ? { mutationName: this.mutationName } : {}
+      });
+    }
     const operations = [];
     const affectedCollections = /* @__PURE__ */ new Set();
     await this.config.adapter.transaction(async (tx) => {
       for (const entry of this.buffer) {
+        if (entry.operation.type === "delete" && this.config.relationEnforcer) {
+          const cascadeResult = await this.config.relationEnforcer.enforceDelete(
+            entry.collection,
+            entry.operation.recordId,
+            tx,
+            [entry.operation.id]
+          );
+          for (const cascadedOp of cascadeResult.operations) {
+            operations.push(cascadedOp);
+            affectedCollections.add(cascadedOp.collection);
+            this.config.causalTracker?.afterOperation(cascadedOp.collection, cascadedOp.id, true);
+          }
+        }
         for (const cmd of entry.commands) {
           await tx.execute(cmd.sql, cmd.params);
         }
         operations.push(entry.operation);
         affectedCollections.add(entry.collection);
       }
+      const finalSeq = this.config.sequenceAllocator.getHighWaterMark();
+      if (finalSeq > 0) {
+        await tx.execute(
+          "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
+          [this.config.nodeId, finalSeq]
+        );
+      }
     });
     return { operations, affectedCollections };
   }
@@ -1811,16 +1591,17 @@ var TransactionContext = class {
   }
   async insert(collectionName, definition, data) {
     this.ensureActive();
-    const validated = validateRecord2(collectionName, definition, data, "insert");
-    const recordId = generateUUIDv72();
+    const validated = validateRecord(collectionName, definition, data, "insert");
+    const recordId = generateUUIDv7();
     const now = Date.now();
     for (const [fieldName, descriptor] of Object.entries(definition.fields)) {
       if (descriptor.auto && descriptor.kind === "timestamp") {
         validated[fieldName] = now;
       }
     }
-    const sequenceNumber = this.config.getSequenceNumber();
-    const operation = await createOperation3(
+    const sequenceNumber = await this.config.sequenceAllocator.allocate();
+    const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
+    const operation = await createOperation2(
       {
         nodeId: this.config.nodeId,
         type: "insert",
@@ -1829,19 +1610,22 @@ var TransactionContext = class {
         data: { ...validated },
         previousData: null,
         sequenceNumber,
-        causalDeps: [],
+        causalDeps,
         schemaVersion: this.config.schema.version,
         transactionId: this.transactionId,
         ...this.mutationName !== void 0 ? { mutationName: this.mutationName } : {}
       },
       this.config.clock
     );
+    this.config.causalTracker?.afterOperation(collectionName, operation.id, true);
     const serializedData = serializeRecord(validated, definition.fields);
+    const version = serializeRowVersion(operation.timestamp);
     const record = {
       id: recordId,
       ...serializedData,
-      _created_at: now,
-      _updated_at: now
+      _created_at: operation.timestamp.wallTime,
+      _updated_at: operation.timestamp.wallTime,
+      _version: version
     };
     const insertQuery = buildInsertQuery(collectionName, record);
     const opRow = serializeOperation(operation);
@@ -1854,11 +1638,7 @@ var TransactionContext = class {
       collection: collectionName,
       commands: [
         { sql: insertQuery.sql, params: insertQuery.params },
-        { sql: opInsert.sql, params: opInsert.params },
-        {
-          sql: "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-          params: [this.config.nodeId, sequenceNumber]
-        }
+        { sql: opInsert.sql, params: opInsert.params }
       ]
     });
     return {
@@ -1874,7 +1654,7 @@ var TransactionContext = class {
     if (!currentRecord) {
       throw new RecordNotFoundError(collectionName, id);
     }
-    const validated = validateRecord2(collectionName, definition, data, "update");
+    const validated = validateRecord(collectionName, definition, data, "update");
     const now = Date.now();
     const previousData = {};
     const resolvedData = {};
@@ -1882,16 +1662,17 @@ var TransactionContext = class {
     for (const key of Object.keys(validated)) {
       const value = validated[key];
       previousData[key] = currentRecord[key];
-      if (isAtomicOp2(value)) {
-        resolvedData[key] = resolveAtomicOp2(currentRecord[key], value);
-        atomicOps[key] = toAtomicOp2(value);
+      if (isAtomicOp(value)) {
+        resolvedData[key] = resolveAtomicOp(currentRecord[key], value);
+        atomicOps[key] = toAtomicOp(value);
       } else {
         resolvedData[key] = value;
       }
     }
     const hasAtomicOps = Object.keys(atomicOps).length > 0;
-    const sequenceNumber = this.config.getSequenceNumber();
-    const operation = await createOperation3(
+    const sequenceNumber = await this.config.sequenceAllocator.allocate();
+    const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
+    const operation = await createOperation2(
       {
         nodeId: this.config.nodeId,
         type: "update",
@@ -1900,7 +1681,7 @@ var TransactionContext = class {
         data: { ...resolvedData },
         previousData,
         sequenceNumber,
-        causalDeps: [],
+        causalDeps,
         schemaVersion: this.config.schema.version,
         transactionId: this.transactionId,
         ...this.mutationName !== void 0 ? { mutationName: this.mutationName } : {},
@@ -1908,10 +1689,13 @@ var TransactionContext = class {
       },
       this.config.clock
     );
+    this.config.causalTracker?.afterOperation(collectionName, operation.id, true);
     const serializedChanges = serializeRecord(resolvedData, definition.fields);
+    const version = serializeRowVersion(operation.timestamp);
     const updateQuery = buildUpdateQuery(collectionName, id, {
       ...serializedChanges,
-      _updated_at: now
+      _updated_at: operation.timestamp.wallTime,
+      _version: version
     });
     const opRow = serializeOperation(operation);
     const opInsert = buildInsertQuery(
@@ -1923,11 +1707,7 @@ var TransactionContext = class {
       collection: collectionName,
       commands: [
         { sql: updateQuery.sql, params: updateQuery.params },
-        { sql: opInsert.sql, params: opInsert.params },
-        {
-          sql: "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-          params: [this.config.nodeId, sequenceNumber]
-        }
+        { sql: opInsert.sql, params: opInsert.params }
       ]
     });
     return {
@@ -1943,8 +1723,9 @@ var TransactionContext = class {
       throw new RecordNotFoundError(collectionName, id);
     }
     const now = Date.now();
-    const sequenceNumber = this.config.getSequenceNumber();
-    const operation = await createOperation3(
+    const sequenceNumber = await this.config.sequenceAllocator.allocate();
+    const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
+    const operation = await createOperation2(
       {
         nodeId: this.config.nodeId,
         type: "delete",
@@ -1953,13 +1734,14 @@ var TransactionContext = class {
         data: null,
         previousData: null,
         sequenceNumber,
-        causalDeps: [],
+        causalDeps,
         schemaVersion: this.config.schema.version,
         transactionId: this.transactionId,
         ...this.mutationName !== void 0 ? { mutationName: this.mutationName } : {}
       },
       this.config.clock
     );
+    this.config.causalTracker?.afterOperation(collectionName, operation.id, true);
     const deleteQuery = buildSoftDeleteQuery(collectionName, id, now);
     const opRow = serializeOperation(operation);
     const opInsert = buildInsertQuery(
@@ -1971,11 +1753,7 @@ var TransactionContext = class {
       collection: collectionName,
       commands: [
         { sql: deleteQuery.sql, params: deleteQuery.params },
-        { sql: opInsert.sql, params: opInsert.params },
-        {
-          sql: "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-          params: [this.config.nodeId, sequenceNumber]
-        }
+        { sql: opInsert.sql, params: opInsert.params }
       ]
     });
   }
@@ -2026,25 +1804,86 @@ var TransactionContext = class {
   }
 };
 
+// src/transaction/transaction-sequence.ts
+var TransactionSequenceAllocator = class {
+  constructor(adapter, nodeId) {
+    this.adapter = adapter;
+    this.nodeId = nodeId;
+  }
+  adapter;
+  nodeId;
+  loaded = false;
+  watermark = 0;
+  async allocate() {
+    if (!this.loaded) {
+      this.watermark = await readSequenceNumber(this.adapter, this.nodeId);
+      this.loaded = true;
+    }
+    this.watermark++;
+    return this.watermark;
+  }
+  getHighWaterMark() {
+    return this.watermark;
+  }
+};
+
+// src/store/tab-node-id.ts
+import { generateUUIDv7 as generateUUIDv72 } from "@korajs/core";
+function perTabStorageKey(dbName) {
+  return `kora-tab-node-${dbName}`;
+}
+function loadPerTabNodeId(dbName) {
+  if (typeof sessionStorage === "undefined") {
+    return null;
+  }
+  return sessionStorage.getItem(perTabStorageKey(dbName));
+}
+function savePerTabNodeId(dbName, nodeId) {
+  if (typeof sessionStorage === "undefined") {
+    return;
+  }
+  sessionStorage.setItem(perTabStorageKey(dbName), nodeId);
+}
+function resolvePerTabNodeId(dbName) {
+  const existing = loadPerTabNodeId(dbName);
+  if (existing) {
+    return existing;
+  }
+  const nodeId = generateUUIDv72();
+  savePerTabNodeId(dbName, nodeId);
+  return nodeId;
+}
+
 // src/store/store.ts
 var Store = class {
   opened = false;
   nodeId = "";
   sequenceNumber = 0;
-  versionVector = createVersionVector();
+  versionVector = createVersionVector3();
   clock = null;
   collections = /* @__PURE__ */ new Map();
-  subscriptionManager = new SubscriptionManager();
+  subscriptionManager;
   sequenceManager = null;
   schema;
   adapter;
   configNodeId;
+  dbName;
+  isolation;
   emitter;
+  localMutationHandler;
+  relationEnforcer = null;
+  causalTracker = null;
   constructor(config) {
     this.schema = config.schema;
     this.adapter = config.adapter;
     this.configNodeId = config.nodeId;
+    this.dbName = config.dbName ?? "kora-db";
+    this.isolation = config.isolation ?? "shared";
     this.emitter = config.emitter ?? null;
+    this.localMutationHandler = config.localMutationHandler ?? null;
+    this.subscriptionManager = new SubscriptionManager({
+      onQuerySubscribed: config.onQuerySubscribed
+    });
   }
   /**
    * Open the store: initialize the database, load or generate a node ID,
@@ -2055,17 +1894,17 @@ var Store = class {
     await this.runMigrationsIfNeeded();
     this.nodeId = await this.loadOrGenerateNodeId();
     this.clock = new HybridLogicalClock2(this.nodeId);
+    this.causalTracker = new CausalTracker();
     this.sequenceManager = new SequenceManager(this.adapter, this.nodeId);
     this.sequenceNumber = await this.loadSequenceNumber();
     this.versionVector = await this.loadVersionVector();
     const hasRelations = Object.keys(this.schema.relations).length > 0;
-    const relationEnforcer = hasRelations ? new RelationEnforcer({
+    this.relationEnforcer = hasRelations ? new RelationEnforcer({
       schema: this.schema,
       adapter: this.adapter,
       clock: this.clock,
-      nodeId: this.nodeId,
-      getSequenceNumber: () => this.nextSequenceNumber()
-    }) : void 0;
+      nodeId: this.nodeId
+    }) : null;
     for (const [name, definition] of Object.entries(this.schema.collections)) {
       const col = new Collection(
         name,
@@ -2074,14 +1913,17 @@ var Store = class {
         this.adapter,
         this.clock,
         this.nodeId,
-        () => this.nextSequenceNumber(),
+        () => this.allocateSequenceNumber(),
         (collectionName, operation) => {
+          this.recordOperationSequence(operation);
           this.subscriptionManager.notify(collectionName, operation);
           if (this.emitter) {
             this.emitter.emit({ type: "operation:created", operation });
           }
         },
-        relationEnforcer
+        this.relationEnforcer,
+        this.localMutationHandler,
+        this.causalTracker
       );
       this.collections.set(name, col);
     }
@@ -2147,7 +1989,7 @@ var Store = class {
    * Checks for duplicates, applies to the data table, persists the operation,
    * and updates the version vector.
    */
-  async applyRemoteOperation(op) {
+  async applyRemoteOperation(op, options) {
     this.ensureOpen();
     const collection = op.collection;
     const definition = this.schema.collections[collection];
@@ -2164,27 +2006,52 @@ var Store = class {
     if (this.clock) {
       this.clock.receive(op.timestamp);
     }
+    const remoteVersion = serializeRowVersion(op.timestamp);
+    const wallTime = op.timestamp.wallTime;
     await this.adapter.transaction(async (tx) => {
       if (op.type === "insert" && op.data) {
-        const serializedData = serializeRecord(op.data, definition.fields);
-        const now = op.timestamp.wallTime;
-        const record = {
-          id: op.recordId,
-          ...serializedData,
-          _created_at: now,
-          _updated_at: now
-        };
-        const insertQuery = buildInsertQuery(collection, record);
-        await tx.execute(insertQuery.sql, insertQuery.params);
+        const existing2 = await tx.query(
+          `SELECT _updated_at, _version FROM ${collection} WHERE id = ?`,
+          [op.recordId]
+        );
+        const row = existing2[0];
+        if (row && !isIncomingNewerThanRow(op.timestamp, row)) {
+        } else {
+          const serializedData = serializeRecord(op.data, definition.fields);
+          const record = {
+            id: op.recordId,
+            ...serializedData,
+            _created_at: wallTime,
+            _updated_at: wallTime,
+            _version: remoteVersion
+          };
+          const insertQuery = buildInsertQuery(collection, record);
+          await tx.execute(insertQuery.sql, insertQuery.params);
+        }
       } else if (op.type === "update" && op.data) {
         const serializedChanges = serializeRecord(op.data, definition.fields);
-        const updateQuery = buildUpdateQuery(collection, op.recordId, {
+        const updatePayload = {
           ...serializedChanges,
-          _updated_at: op.timestamp.wallTime
-        });
+          _updated_at: wallTime,
+          _version: remoteVersion
+        };
+        if (options?.reactivateIfDeleted) {
+          updatePayload._deleted = 0;
+        }
+        const updateQuery = buildLwwUpdateQuery(
+          collection,
+          op.recordId,
+          updatePayload,
+          remoteVersion
+        );
         await tx.execute(updateQuery.sql, updateQuery.params);
       } else if (op.type === "delete") {
-        const deleteQuery = buildSoftDeleteQuery(collection, op.recordId, op.timestamp.wallTime);
+        const deleteQuery = buildLwwSoftDeleteQuery(
+          collection,
+          op.recordId,
+          wallTime,
+          remoteVersion
+        );
         await tx.execute(deleteQuery.sql, deleteQuery.params);
       }
       const opRow = serializeOperation(op);
@@ -2209,11 +2076,11 @@ var Store = class {
    * Get operations from a node within a sequence number range.
    * Implements the OperationLog interface for computeDelta.
    */
-  getRange(nodeId, fromSeq, toSeq) {
-    return [];
+  async getRange(nodeId, fromSeq, toSeq) {
+    return this.getOperationRange(nodeId, fromSeq, toSeq);
   }
   /**
-   * Async version of getRange for use by the sync layer.
+   * Get operations from a node within a sequence number range.
    */
   async getOperationRange(nodeId, fromSeq, toSeq) {
     this.ensureOpen();
@@ -2230,12 +2097,233 @@ var Store = class {
     allOps.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
     return allOps;
   }
+  /**
+   * Load every operation from the local append-only log across all collections.
+   * Used by sync delta computation, backup export, and time-travel replay.
+   */
+  async getAllOperations() {
+    this.ensureOpen();
+    const allOps = [];
+    for (const collectionName of Object.keys(this.schema.collections)) {
+      const rows = await this.adapter.query(
+        `SELECT * FROM _kora_ops_${collectionName} ORDER BY sequence_number ASC`
+      );
+      for (const row of rows) {
+        allOps.push(deserializeOperationWithCollection(row, collectionName));
+      }
+    }
+    return allOps;
+  }
+  /**
+   * Rebuild an in-memory snapshot of materialized state at a causal cut in the op log.
+   * Does not mutate the live store — intended for DevTools time-travel inspection.
+   *
+   * @param operationId - Content-addressed id of the operation to replay through (inclusive)
+   * @throws {OperationError} When the operation id is not present in the local log
+   */
+  async replayTo(operationId) {
+    this.ensureOpen();
+    const start = Date.now();
+    const allOps = await this.getAllOperations();
+    const snapshot = buildReplaySnapshot(this.schema, allOps, operationId);
+    if (this.emitter) {
+      this.emitter.emit({
+        type: "replay:completed",
+        targetOperationId: operationId,
+        operationsApplied: snapshot.operationsApplied.length,
+        duration: Date.now() - start
+      });
+    }
+    return snapshot;
+  }
+  /**
+   * Persist a merge trace to the durable audit log.
+   */
+  async appendAuditTrace(trace) {
+    this.ensureOpen();
+    const { appendAuditTrace: append } = await import("./audit-trace-store-AM4EWQNZ.js");
+    await append(this.adapter, trace);
+  }
+  /**
+   * Read persisted audit traces with optional filters.
+   */
+  async getAuditTraces(query) {
+    this.ensureOpen();
+    const { readAuditTraces: readAuditTraces2 } = await import("./audit-trace-store-AM4EWQNZ.js");
+    return readAuditTraces2(this.adapter, query);
+  }
+  /**
+   * Export operations and merge traces as a portable audit bundle.
+   */
+  async exportAudit(options) {
+    this.ensureOpen();
+    const { exportAudit: doExport } = await import("./export-audit-5GV6VRDZ.js");
+    return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
+  }
   /**
    * Get the schema definition.
    */
   getSchema() {
     return this.schema;
   }
+  /**
+   * Route local CRUD through the unified apply pipeline (korajs ApplyPipeline).
+   */
+  setLocalMutationHandler(handler) {
+    this.localMutationHandler = handler;
+    for (const col of this.collections.values()) {
+      col.setMutationHandler(handler);
+    }
+  }
+  /**
+   * Build mutation context for a collection (used by ApplyPipeline side effects).
+   */
+  createMutationContext(collection, options) {
+    this.ensureOpen();
+    const definition = this.schema.collections[collection];
+    if (!definition || !this.clock) {
+      throw new StoreNotOpenError();
+    }
+    return {
+      collection,
+      definition,
+      schema: this.schema,
+      adapter: this.adapter,
+      clock: this.clock,
+      nodeId: this.nodeId,
+      allocateSequenceNumber: () => this.allocateSequenceNumber(),
+      onMutation: (collectionName, operation) => {
+        this.recordOperationSequence(operation);
+        this.subscriptionManager.notify(collectionName, operation);
+        if (this.emitter) {
+          this.emitter.emit({ type: "operation:created", operation });
+        }
+      },
+      relationEnforcer: this.relationEnforcer,
+      causalTracker: this.causalTracker,
+      inTransaction: options?.inTransaction ?? false,
+      extraCausalDeps: options?.extraCausalDeps
+    };
+  }
+  /**
+   * Load a materialized row by ID, including soft-deleted tombstones.
+   */
+  async findMaterializedRow(collection, recordId) {
+    this.ensureOpen();
+    const definition = this.schema.collections[collection];
+    if (!definition) {
+      return null;
+    }
+    const rows = await this.adapter.query(
+      `SELECT * FROM ${collection} WHERE id = ?`,
+      [recordId]
+    );
+    const row = rows[0];
+    if (!row) {
+      return null;
+    }
+    return {
+      record: deserializeRecord(row, definition.fields),
+      deleted: row._deleted === 1
+    };
+  }
+  /**
+   * Latest operation from this device for a record (used for delete-vs-update merge on sync).
+   */
+  /**
+   * Load the last server version vector acknowledged by this client (persisted in `_kora_meta`).
+   */
+  async loadLastAckedServerVector() {
+    this.ensureOpen();
+    return loadLastAckedServerVector(this.adapter);
+  }
+  /**
+   * Persist the last server version vector this client believes the server has applied.
+   */
+  async saveLastAckedServerVector(vector) {
+    this.ensureOpen();
+    await saveLastAckedServerVector(this.adapter, vector);
+  }
+  /**
+   * Load persisted delta cursor for resuming paginated initial sync.
+   */
+  async loadDeltaCursor() {
+    this.ensureOpen();
+    return loadDeltaCursor(this.adapter);
+  }
+  /**
+   * Persist or clear the delta cursor for paginated initial sync resume.
+   */
+  async saveDeltaCursor(cursor) {
+    this.ensureOpen();
+    await saveDeltaCursor(this.adapter, cursor);
+  }
+  /**
+   * Local operations not yet reflected on the server version vector.
+   */
+  async getUnsyncedOperations(serverVector) {
+    this.ensureOpen();
+    return collectOperationsAheadOfServer(
+      this.getVersionVector(),
+      serverVector,
+      (nodeId, fromSeq, toSeq) => this.getOperationRange(nodeId, fromSeq, toSeq)
+    );
+  }
+  /**
+   * Count of local operations ahead of the server version vector.
+   */
+  async countUnsyncedOperations(serverVector) {
+    const ops = await this.getUnsyncedOperations(serverVector);
+    return ops.length;
+  }
+  /**
+   * Compact the local operation log using materialized rows as the baseline.
+   * Only removes ops the server has acknowledged (per {@link CompactionStrategy}).
+   */
+  async compact(strategy) {
+    this.ensureOpen();
+    if (strategy.mode === "never") {
+      return compactOperationLog(this.adapter, this.schema, strategy, createVersionVector3());
+    }
+    const serverVector = strategy.serverVector ?? await loadLastAckedServerVector(this.adapter);
+    return compactOperationLog(this.adapter, this.schema, strategy, serverVector);
+  }
+  /**
+   * Merge session remote vector with persisted last-acked vector (max per node).
+   */
+  mergeServerVectors(sessionVector, persistedVector) {
+    return mergeVersionVectors(persistedVector, sessionVector);
+  }
+  async getLatestLocalOperationForRecord(collection, recordId) {
+    this.ensureOpen();
+    const rows = await this.adapter.query(
+      `SELECT * FROM _kora_ops_${collection} WHERE node_id = ? AND record_id = ? ORDER BY sequence_number DESC LIMIT 1`,
+      [this.nodeId, recordId]
+    );
+    const row = rows[0];
+    if (!row) {
+      return null;
+    }
+    return deserializeOperationWithCollection(row, collection);
+  }
+  /**
+   * Latest operation for a record from any node (for 3-way merge when local op log is empty).
+   */
+  async getLatestOperationForRecord(collection, recordId) {
+    this.ensureOpen();
+    const rows = await this.adapter.query(
+      `SELECT * FROM _kora_ops_${collection} WHERE record_id = ?`,
+      [recordId]
+    );
+    let latest = null;
+    for (const row of rows) {
+      const op = deserializeOperationWithCollection(row, collection);
+      if (!latest || HybridLogicalClock2.compare(op.timestamp, latest.timestamp) > 0) {
+        latest = op;
+      }
+    }
+    return latest;
+  }
   /** Expose the subscription manager for direct access (e.g., by QueryBuilder) */
   getSubscriptionManager() {
     return this.subscriptionManager;
@@ -2268,7 +2356,10 @@ var Store = class {
       adapter: this.adapter,
       clock: this.clock,
       nodeId: this.nodeId,
-      getSequenceNumber: () => this.nextSequenceNumber()
+      sequenceAllocator: new TransactionSequenceAllocator(this.adapter, this.nodeId),
+      relationEnforcer: this.relationEnforcer,
+      causalTracker: this.causalTracker,
+      localMutationHandler: this.localMutationHandler
     });
   }
   /**
@@ -2283,10 +2374,13 @@ var Store = class {
    */
   async transaction(fn) {
     const tx = this.createTransaction();
+    this.causalTracker?.beginTransaction();
     try {
       await fn(tx);
-      const { operations, affectedCollections } = await tx.commit();
+      const { operations } = await tx.commit();
+      this.causalTracker?.clearTransaction();
       for (const op of operations) {
+        this.recordOperationSequence(op);
         this.subscriptionManager.notify(op.collection, op);
         if (this.emitter) {
           this.emitter.emit({ type: "operation:created", operation: op });
@@ -2295,13 +2389,57 @@ var Store = class {
       return operations;
     } catch (error) {
       tx.rollback();
+      this.causalTracker?.clearTransaction();
       throw error;
     }
   }
-  nextSequenceNumber() {
-    this.sequenceNumber++;
-    this.versionVector.set(this.nodeId, this.sequenceNumber);
-    return this.sequenceNumber;
+  /**
+   * Export all data as a portable backup binary.
+   * Includes operations, version vector, metadata, and optionally materialized records.
+   *
+   * @param options - Backup options (includeRecords, collections, onProgress)
+   * @returns Backup as a Uint8Array
+   */
+  async exportBackup(options) {
+    this.ensureOpen();
+    const { exportBackup: doExport } = await import("./backup-JN3LB4YT.js");
+    return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
+  }
+  /**
+   * Restore data from a backup binary.
+   *
+   * @param data - The backup data
+   * @param options - Restore options (merge, collections, onProgress)
+   * @returns Result of the restore operation
+   */
+  async importBackup(data, options) {
+    this.ensureOpen();
+    const { restoreBackup: doRestore } = await import("./backup-JN3LB4YT.js");
+    return doRestore(this.adapter, this.schema, data, options);
+  }
+  /**
+   * Read backup manifest without loading the entire backup.
+   *
+   * @param data - The raw backup data
+   * @returns The backup manifest
+   */
+  static readBackupManifest(data) {
+    return readBackupManifest(data);
+  }
+  recordOperationSequence(operation) {
+    const prev = this.versionVector.get(operation.nodeId) ?? 0;
+    if (operation.sequenceNumber > prev) {
+      this.versionVector.set(operation.nodeId, operation.sequenceNumber);
+    }
+    if (operation.nodeId === this.nodeId) {
+      this.sequenceNumber = Math.max(this.sequenceNumber, operation.sequenceNumber);
+    }
+  }
+  async allocateSequenceNumber() {
+    const seq = await allocateNextSequenceNumber(this.adapter, this.nodeId);
+    this.sequenceNumber = seq;
+    this.versionVector.set(this.nodeId, seq);
+    return seq;
   }
   /**
    * Check the stored schema version and run any pending migrations.
@@ -2384,12 +2522,17 @@ var Store = class {
   }
   async loadOrGenerateNodeId() {
     if (this.configNodeId) {
-      await this.adapter.execute(
-        "INSERT OR REPLACE INTO _kora_meta (key, value) VALUES ('node_id', ?)",
-        [this.configNodeId]
-      );
+      if (this.isolation !== "per-tab") {
+        await this.adapter.execute(
+          "INSERT OR REPLACE INTO _kora_meta (key, value) VALUES ('node_id', ?)",
+          [this.configNodeId]
+        );
+      }
       return this.configNodeId;
     }
+    if (this.isolation === "per-tab") {
+      return resolvePerTabNodeId(this.dbName);
+    }
     const rows = await this.adapter.query(
       "SELECT value FROM _kora_meta WHERE key = 'node_id'"
     );
@@ -2413,7 +2556,7 @@ var Store = class {
     const rows = await this.adapter.query(
       "SELECT node_id, sequence_number FROM _kora_version_vector"
     );
-    const vector = createVersionVector();
+    const vector = createVersionVector3();
     for (const row of rows) {
       vector.set(row.node_id, row.sequence_number);
     }
@@ -2425,13 +2568,493 @@ 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,
   PersistenceError,
   QueryBuilder,
   QueryError,
+  QueryStore,
+  QueryStoreCache,
   RecordNotFoundError,
   SequenceManager,
   Store,
@@ -2441,12 +3064,31 @@ export {
   TransactionContext,
   WorkerInitError,
   WorkerTimeoutError,
+  asRichTextSyncEngine,
+  assertQueryReady,
+  collectOperationsAheadOfServer,
+  compactOperationLog,
+  computeAckCompactionWatermark,
+  createRichTextController,
+  decodeAuditExport,
   decodeRichtext,
+  deserializeVersionVectorFromMeta,
   encodeRichtext,
+  exportBackup,
+  getSharedQueryStoreCache,
+  mergeVersionVectors,
+  persistedAuditTraceFromEvent,
   pluralize,
+  readAuditExportManifest,
+  readBackupManifest,
+  restoreBackup,
+  richtextStatesEqual,
   richtextToPlainText,
+  serializeVersionVectorToMeta,
   singularize,
   validateStateTransition,
-  validateUpdateStateMachine
+  validateUpdateStateMachine,
+  verifyAuditExportChecksum,
+  verifyBackupChecksum
 };
 //# sourceMappingURL=index.js.map