@korajs/store 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/index.cjs

@@ -69,6 +69,7 @@ function encodeRichtext(value) {
   }
   if (typeof value === "string") {
     const doc = new Y.Doc();
+    doc.clientID = 0;
     doc.getText(TEXT_KEY).insert(0, value);
     return Y.encodeStateAsUpdate(doc);
   }
@@ -528,7 +529,7 @@ async function restoreBackup(adapter, schema, data, options) {
           schema_version: op.schemaVersion
         };
         await tx.execute(
-          `INSERT OR IGNORE INTO _kora_ops_${collection} (id, node_id, type, record_id, data, previous_data, timestamp, sequence_number, causal_deps, schema_version) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          `INSERT OR IGNORE INTO ${(0, import_core6.quoteIdent)(`_kora_ops_${collection}`)} (id, node_id, type, record_id, data, previous_data, timestamp, sequence_number, causal_deps, schema_version) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
           [
             opRow.id,
             opRow.node_id,
@@ -547,8 +548,8 @@ async function restoreBackup(adapter, schema, data, options) {
   } else {
     await adapter.transaction(async (tx) => {
       for (const collection of Object.keys(schema.collections)) {
-        await tx.execute(`DELETE FROM _kora_ops_${collection}`);
-        await tx.execute(`DELETE FROM ${collection}`);
+        await tx.execute(`DELETE FROM ${(0, import_core6.quoteIdent)(`_kora_ops_${collection}`)}`);
+        await tx.execute(`DELETE FROM ${(0, import_core6.quoteIdent)(collection)}`);
       }
       await tx.execute("DELETE FROM _kora_version_vector");
       await tx.execute("DELETE FROM _kora_meta");
@@ -568,7 +569,7 @@ async function restoreBackup(adapter, schema, data, options) {
       for (const op of operations) {
         const collection = op.collection;
         await tx.execute(
-          `INSERT INTO _kora_ops_${collection} (id, node_id, type, record_id, data, previous_data, timestamp, sequence_number, causal_deps, schema_version) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          `INSERT INTO ${(0, import_core6.quoteIdent)(`_kora_ops_${collection}`)} (id, node_id, type, record_id, data, previous_data, timestamp, sequence_number, causal_deps, schema_version) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
           [
             op.id,
             op.nodeId,
@@ -600,6 +601,7 @@ async function restoreBackup(adapter, schema, data, options) {
         for (const record of records) {
           const keys = Object.keys(record);
           const placeholders = keys.map(() => "?").join(", ");
+          const quotedKeys = keys.map((k) => (0, import_core6.quoteIdent)(k)).join(", ");
           const values = keys.map((k) => {
             const v = record[k];
             if (typeof v === "boolean") return v ? 1 : 0;
@@ -607,7 +609,7 @@ async function restoreBackup(adapter, schema, data, options) {
             return v;
           });
           await tx.execute(
-            `INSERT OR REPLACE INTO ${col} (${keys.join(", ")}) VALUES (${placeholders})`,
+            `INSERT OR REPLACE INTO ${(0, import_core6.quoteIdent)(col)} (${quotedKeys}) VALUES (${placeholders})`,
             values
           );
         }
@@ -640,7 +642,7 @@ async function readAllOperations(adapter, schema) {
   const allOps = [];
   for (const collectionName of Object.keys(schema.collections)) {
     const rows = await adapter.query(
-      `SELECT * FROM _kora_ops_${collectionName} ORDER BY sequence_number ASC`
+      `SELECT * FROM ${(0, import_core6.quoteIdent)(`_kora_ops_${collectionName}`)} ORDER BY sequence_number ASC`
     );
     for (const row of rows) {
       allOps.push(deserializeOperationWithCollection(row, collectionName));
@@ -649,7 +651,9 @@ async function readAllOperations(adapter, schema) {
   return allOps;
 }
 async function readCollectionRecords(adapter, collection) {
-  return adapter.query(`SELECT * FROM ${collection} WHERE _deleted = 0`);
+  return adapter.query(
+    `SELECT * FROM ${(0, import_core6.quoteIdent)(collection)} WHERE _deleted = 0`
+  );
 }
 async function computeSha256(data) {
   const hashBuffer = await crypto.subtle.digest("SHA-256", data);
@@ -717,7 +721,7 @@ __export(audit_trace_store_exports, {
 });
 function persistedAuditTraceFromEvent(event) {
   return {
-    id: (0, import_core18.generateUUIDv7)(),
+    id: (0, import_core21.generateUUIDv7)(),
     recordedAt: Date.now(),
     eventType: event.type,
     constraint: event.type === "constraint:violated" ? event.constraint : void 0,
@@ -783,11 +787,11 @@ function auditTraceIndexFields(trace) {
     recordId: trace.operationA.recordId
   };
 }
-var import_core18;
+var import_core21;
 var init_audit_trace_store = __esm({
   "src/audit/audit-trace-store.ts"() {
     "use strict";
-    import_core18 = require("@korajs/core");
+    import_core21 = require("@korajs/core");
     init_audit_json();
   }
 });
@@ -859,7 +863,7 @@ async function readAllOperations2(adapter, schema, collectionFilter) {
   const allOps = [];
   for (const collectionName of collections) {
     const rows = await adapter.query(
-      `SELECT * FROM _kora_ops_${collectionName} ORDER BY sequence_number ASC`
+      `SELECT * FROM ${(0, import_core22.quoteIdent)(`_kora_ops_${collectionName}`)} ORDER BY sequence_number ASC`
     );
     for (const row of rows) {
       allOps.push(deserializeOperationWithCollection(row, collectionName));
@@ -970,9 +974,11 @@ function parseNdjsonSection(content) {
   }
   return text.split("\n").map((line) => deserializeAuditJson(line));
 }
+var import_core22;
 var init_export_audit = __esm({
   "src/audit/export-audit.ts"() {
     "use strict";
+    import_core22 = require("@korajs/core");
     init_serializer();
     init_audit_json();
     init_audit_trace_store();
@@ -990,6 +996,7 @@ __export(index_exports, {
   InvalidStateTransitionError: () => InvalidStateTransitionError,
   LAST_ACKED_SERVER_VECTOR_META_KEY: () => LAST_ACKED_SERVER_VECTOR_META_KEY,
   MemoryBlobStore: () => MemoryBlobStore,
+  NoLeaderError: () => NoLeaderError,
   OpfsBlobStore: () => OpfsBlobStore,
   OptimisticLockError: () => OptimisticLockError,
   PersistenceError: () => PersistenceError,
@@ -1108,6 +1115,16 @@ var WorkerTimeoutError = class extends import_core.KoraError {
     this.name = "WorkerTimeoutError";
   }
 };
+var NoLeaderError = class extends import_core.KoraError {
+  constructor(operation) {
+    super(
+      `No live leader tab is answering multi-tab storage RPC for operation "${operation}"`,
+      "NO_LEADER",
+      { operation }
+    );
+    this.name = "NoLeaderError";
+  }
+};
 var PersistenceError = class extends import_core.KoraError {
   constructor(message, context) {
     super(`Persistence error: ${message}`, "PERSISTENCE_ERROR", context);
@@ -1147,7 +1164,7 @@ async function compactOperationLog(adapter, schema, strategy, serverVector) {
   const collectionNames = Object.keys(schema.collections);
   await adapter.transaction(async (tx) => {
     for (const collectionName of collectionNames) {
-      const table = `_kora_ops_${collectionName}`;
+      const table = (0, import_core2.quoteIdent)(`_kora_ops_${collectionName}`);
       for (const [nodeId, maxSeq] of watermark) {
         if (maxSeq <= 0) continue;
         const countSql = buildCountSql(table, ageCutoffSerialized !== null);
@@ -1182,6 +1199,7 @@ function buildDeleteSql(table, withAge) {
 var import_core3 = require("@korajs/core");
 var LAST_ACKED_SERVER_VECTOR_META_KEY = "last_acked_server_vector";
 var DELTA_CURSOR_META_KEY = "delta_cursor";
+var DELIVERY_WATERMARK_META_KEY = "delivery_watermark";
 function serializeVersionVectorToMeta(vector) {
   const record = {};
   for (const [nodeId, seq] of vector) {
@@ -1254,13 +1272,55 @@ async function saveDeltaCursor(adapter, cursor) {
     cursor
   ]);
 }
+function deliveryWatermarkKey(signature) {
+  return signature === "" ? DELIVERY_WATERMARK_META_KEY : `${DELIVERY_WATERMARK_META_KEY}:${signature}`;
+}
+async function loadDeliveryWatermark(adapter, signature) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    deliveryWatermarkKey(signature)
+  ]);
+  const value = rows[0]?.value;
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+}
+async function saveDeliveryWatermark(adapter, signature, watermark) {
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    deliveryWatermarkKey(signature),
+    String(watermark)
+  ]);
+}
+async function deleteDeliveryWatermark(adapter, signature) {
+  await adapter.execute("DELETE FROM _kora_meta WHERE key = ?", [deliveryWatermarkKey(signature)]);
+}
+async function loadAllDeliveryWatermarks(adapter) {
+  const rows = await adapter.query(
+    "SELECT key, value FROM _kora_meta WHERE key = ? OR key LIKE ?",
+    [DELIVERY_WATERMARK_META_KEY, `${DELIVERY_WATERMARK_META_KEY}:%`]
+  );
+  const result = {};
+  const prefix = `${DELIVERY_WATERMARK_META_KEY}:`;
+  for (const row of rows) {
+    const signature = row.key === DELIVERY_WATERMARK_META_KEY ? "" : row.key.slice(prefix.length);
+    const parsed = Number(row.value);
+    if (Number.isFinite(parsed) && parsed >= 0) {
+      result[signature] = parsed;
+    }
+  }
+  return result;
+}
 
 // src/store/store.ts
-var import_core19 = require("@korajs/core");
+var import_core23 = require("@korajs/core");
 init_backup();
 
+// src/collection/collection.ts
+var import_core13 = require("@korajs/core");
+
 // src/mutations/execute-delete.ts
-var import_core8 = require("@korajs/core");
+var import_core9 = require("@korajs/core");
 
 // src/lww/row-version.ts
 var import_core7 = require("@korajs/core");
@@ -1286,9 +1346,10 @@ function lwwVersionWhereClause(remoteVersion) {
 }
 
 // src/query/sql-builder.ts
+var import_core8 = require("@korajs/core");
 function buildSelectQuery(descriptor, fields) {
   const params = [];
-  const parts = [`SELECT * FROM ${descriptor.collection}`];
+  const parts = [`SELECT * FROM ${(0, import_core8.quoteIdent)(descriptor.collection)}`];
   const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
   const deletedFilter = "_deleted = 0";
   if (whereClause) {
@@ -1299,7 +1360,7 @@ function buildSelectQuery(descriptor, fields) {
   if (descriptor.orderBy.length > 0) {
     const orderParts = descriptor.orderBy.map((o) => {
       validateFieldName(o.field, fields);
-      return `${o.field} ${o.direction.toUpperCase()}`;
+      return `${(0, import_core8.quoteIdent)(o.field)} ${o.direction.toUpperCase()}`;
     });
     parts.push(`ORDER BY ${orderParts.join(", ")}`);
   }
@@ -1313,7 +1374,7 @@ function buildSelectQuery(descriptor, fields) {
 }
 function buildCountQuery(descriptor, fields) {
   const params = [];
-  const parts = [`SELECT COUNT(*) as count FROM ${descriptor.collection}`];
+  const parts = [`SELECT COUNT(*) as count FROM ${(0, import_core8.quoteIdent)(descriptor.collection)}`];
   const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
   const deletedFilter = "_deleted = 0";
   if (whereClause) {
@@ -1327,17 +1388,18 @@ 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(", ")})`;
+  const quotedColumns = columns.map((col) => (0, import_core8.quoteIdent)(col));
+  const sql = `INSERT INTO ${(0, import_core8.quoteIdent)(collection)} (${quotedColumns.join(", ")}) VALUES (${placeholders.join(", ")})`;
   return { sql, params };
 }
 function buildUpdateQuery(collection, id, changes) {
-  const setClauses = Object.keys(changes).map((col) => `${col} = ?`);
+  const setClauses = Object.keys(changes).map((col) => `${(0, import_core8.quoteIdent)(col)} = ?`);
   const params = [...Object.values(changes), id];
-  const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ?`;
+  const sql = `UPDATE ${(0, import_core8.quoteIdent)(collection)} SET ${setClauses.join(", ")} WHERE id = ?`;
   return { sql, params };
 }
 function buildFieldFastForwardUpdateQuery(collection, id, fieldChanges, remoteVersion, wallTime, options) {
-  const fieldClauses = Object.keys(fieldChanges).map((col) => `${col} = ?`);
+  const fieldClauses = Object.keys(fieldChanges).map((col) => `${(0, import_core8.quoteIdent)(col)} = ?`);
   const setClauses = [
     ...fieldClauses,
     "_version = CASE WHEN _version >= ? THEN _version ELSE ? END",
@@ -1355,25 +1417,25 @@ function buildFieldFastForwardUpdateQuery(collection, id, fieldChanges, remoteVe
     params.push(options.maxCreatedAt, options.maxCreatedAt);
   }
   params.push(id);
-  const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ?`;
+  const sql = `UPDATE ${(0, import_core8.quoteIdent)(collection)} SET ${setClauses.join(", ")} WHERE id = ?`;
   return { sql, params };
 }
 function buildSoftDeleteQuery(collection, id, updatedAt, version) {
   if (version !== void 0) {
     return {
-      sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ?`,
+      sql: `UPDATE ${(0, import_core8.quoteIdent)(collection)} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ?`,
       params: [updatedAt, version, id]
     };
   }
   return {
-    sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ? WHERE id = ?`,
+    sql: `UPDATE ${(0, import_core8.quoteIdent)(collection)} SET _deleted = 1, _updated_at = ? WHERE id = ?`,
     params: [updatedAt, id]
   };
 }
 function buildLwwSoftDeleteQuery(collection, id, updatedAt, version) {
   const lww = lwwVersionWhereClause(version);
   return {
-    sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ? AND ${lww.sql}`,
+    sql: `UPDATE ${(0, import_core8.quoteIdent)(collection)} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ? AND ${lww.sql}`,
     params: [updatedAt, version, id, ...lww.params]
   };
 }
@@ -1404,31 +1466,32 @@ function buildWhereClauseParts(where, fields, params) {
 }
 function buildOperatorCondition(fieldName, operator, value, descriptor, params) {
   const sqlValue = descriptor?.kind === "boolean" && typeof value === "boolean" ? value ? 1 : 0 : value;
+  const column = (0, import_core8.quoteIdent)(fieldName);
   switch (operator) {
     case "$eq":
       if (sqlValue === null) {
-        return `${fieldName} IS NULL`;
+        return `${column} IS NULL`;
       }
       params.push(sqlValue);
-      return `${fieldName} = ?`;
+      return `${column} = ?`;
     case "$ne":
       if (sqlValue === null) {
-        return `${fieldName} IS NOT NULL`;
+        return `${column} IS NOT NULL`;
       }
       params.push(sqlValue);
-      return `${fieldName} != ?`;
+      return `${column} != ?`;
     case "$gt":
       params.push(sqlValue);
-      return `${fieldName} > ?`;
+      return `${column} > ?`;
     case "$gte":
       params.push(sqlValue);
-      return `${fieldName} >= ?`;
+      return `${column} >= ?`;
     case "$lt":
       params.push(sqlValue);
-      return `${fieldName} < ?`;
+      return `${column} < ?`;
     case "$lte":
       params.push(sqlValue);
-      return `${fieldName} <= ?`;
+      return `${column} <= ?`;
     case "$in": {
       if (!Array.isArray(sqlValue)) {
         throw new QueryError(`$in operator requires an array value for field "${fieldName}"`, {
@@ -1442,7 +1505,7 @@ function buildOperatorCondition(fieldName, operator, value, descriptor, params)
           descriptor?.kind === "boolean" && typeof item === "boolean" ? item ? 1 : 0 : item
         );
       }
-      return `${fieldName} IN (${placeholders.join(", ")})`;
+      return `${column} IN (${placeholders.join(", ")})`;
     }
     default:
       throw new QueryError(`Unknown operator "${operator}"`, { operator });
@@ -1522,7 +1585,7 @@ function resolveCausalDeps(ctx) {
 // src/mutations/execute-delete.ts
 async function executeDelete(ctx, id, options) {
   const currentRows = await ctx.adapter.query(
-    `SELECT * FROM ${ctx.collection} WHERE id = ? AND _deleted = 0`,
+    `SELECT * FROM ${(0, import_core9.quoteIdent)(ctx.collection)} WHERE id = ? AND _deleted = 0`,
     [id]
   );
   if (!currentRows[0]) {
@@ -1534,7 +1597,7 @@ async function executeDelete(ctx, id, options) {
   await ctx.adapter.transaction(async (tx) => {
     if (!operation) {
       const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
-      operation = await (0, import_core8.createOperation)(
+      operation = await (0, import_core9.createOperation)(
         {
           nodeId: ctx.nodeId,
           type: "delete",
@@ -1581,7 +1644,7 @@ async function executeDelete(ctx, id, options) {
 }
 
 // src/mutations/execute-insert.ts
-var import_core9 = require("@korajs/core");
+var import_core10 = require("@korajs/core");
 
 // src/lww/field-versions.ts
 function parseFieldVersions(raw) {
@@ -1638,14 +1701,14 @@ function resolvePerFieldLww(current, incomingFields, incomingVersion, rowVersion
 init_op_data_encoding();
 init_serializer();
 async function executeInsert(ctx, data) {
-  const validated = (0, import_core9.validateRecord)(ctx.collection, ctx.definition, data, "insert");
-  const recordId = (0, import_core9.generateUUIDv7)();
+  const validated = (0, import_core10.validateRecord)(ctx.collection, ctx.definition, data, "insert");
+  const recordId = (0, import_core10.generateUUIDv7)();
   for (const [fieldName, descriptor] of Object.entries(ctx.definition.fields)) {
     if (descriptor.auto && descriptor.kind === "timestamp") {
       validated[fieldName] = Date.now();
     }
   }
-  const writeData = await (0, import_core9.transformSecretFieldsForWrite)(
+  const writeData = await (0, import_core10.transformSecretFieldsForWrite)(
     validated,
     ctx.definition,
     ctx.secretKeyProvider
@@ -1655,7 +1718,7 @@ async function executeInsert(ctx, data) {
   let record;
   await ctx.adapter.transaction(async (tx) => {
     const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
-    operation = await (0, import_core9.createOperation)(
+    operation = await (0, import_core10.createOperation)(
       {
         nodeId: ctx.nodeId,
         type: "insert",
@@ -1705,13 +1768,13 @@ async function executeInsert(ctx, data) {
 }
 
 // src/mutations/execute-update.ts
-var import_core11 = require("@korajs/core");
+var import_core12 = require("@korajs/core");
 init_op_data_encoding();
 init_serializer();
 
 // src/state-machine/state-validator.ts
-var import_core10 = require("@korajs/core");
-var InvalidStateTransitionError = class extends import_core10.KoraError {
+var import_core11 = require("@korajs/core");
+var InvalidStateTransitionError = class extends import_core11.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)"}`,
@@ -1745,7 +1808,7 @@ function validateStateTransition(collectionName, recordId, stateMachine, current
     collection: collectionName,
     transitions: stateMachine.transitions
   };
-  const transitionResult = (0, import_core10.validateTransition)(constraint, currentState, newState);
+  const transitionResult = (0, import_core11.validateTransition)(constraint, currentState, newState);
   if (transitionResult.valid) {
     return { valid: true, allowedStates: transitionResult.allowedTargets };
   }
@@ -1794,14 +1857,14 @@ function validateUpdateStateMachine(collectionName, recordId, collectionDef, cur
 // src/mutations/execute-update.ts
 async function executeUpdate(ctx, id, data) {
   const currentRows = await ctx.adapter.query(
-    `SELECT * FROM ${ctx.collection} WHERE id = ? AND _deleted = 0`,
+    `SELECT * FROM ${(0, import_core12.quoteIdent)(ctx.collection)} WHERE id = ? AND _deleted = 0`,
     [id]
   );
   const currentRow = currentRows[0];
   if (!currentRow) {
     throw new RecordNotFoundError(ctx.collection, id);
   }
-  let validated = (0, import_core11.validateRecord)(ctx.collection, ctx.definition, data, "update");
+  let validated = (0, import_core12.validateRecord)(ctx.collection, ctx.definition, data, "update");
   const currentRecord = deserializeRecord(currentRow, ctx.definition.fields);
   validated = validateUpdateStateMachine(
     ctx.collection,
@@ -1819,14 +1882,14 @@ async function executeUpdate(ctx, id, data) {
   for (const key of Object.keys(validated)) {
     const value = validated[key];
     previousData[key] = currentRecord[key];
-    if ((0, import_core11.isAtomicOp)(value)) {
-      resolvedData[key] = (0, import_core11.resolveAtomicOp)(currentRecord[key], value);
-      atomicOps[key] = (0, import_core11.toAtomicOp)(value);
+    if ((0, import_core12.isAtomicOp)(value)) {
+      resolvedData[key] = (0, import_core12.resolveAtomicOp)(currentRecord[key], value);
+      atomicOps[key] = (0, import_core12.toAtomicOp)(value);
     } else {
       resolvedData[key] = value;
     }
   }
-  const writeData = await (0, import_core11.transformSecretFieldsForWrite)(
+  const writeData = await (0, import_core12.transformSecretFieldsForWrite)(
     resolvedData,
     ctx.definition,
     ctx.secretKeyProvider
@@ -1836,7 +1899,7 @@ async function executeUpdate(ctx, id, data) {
   let operation;
   await ctx.adapter.transaction(async (tx) => {
     const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
-    operation = await (0, import_core11.createOperation)(
+    operation = await (0, import_core12.createOperation)(
       {
         nodeId: ctx.nodeId,
         type: "update",
@@ -1876,7 +1939,7 @@ async function executeUpdate(ctx, id, data) {
   });
   ctx.onMutation(ctx.collection, operation);
   const rows = await ctx.adapter.query(
-    `SELECT * FROM ${ctx.collection} WHERE id = ? AND _deleted = 0`,
+    `SELECT * FROM ${(0, import_core12.quoteIdent)(ctx.collection)} WHERE id = ? AND _deleted = 0`,
     [id]
   );
   const row = rows[0];
@@ -1939,7 +2002,7 @@ var Collection = class {
   }
   async findById(id) {
     const rows = await this.adapter.query(
-      `SELECT * FROM ${this.name} WHERE id = ? AND _deleted = 0`,
+      `SELECT * FROM ${(0, import_core13.quoteIdent)(this.name)} WHERE id = ? AND _deleted = 0`,
       [id]
     );
     const row = rows[0];
@@ -1972,6 +2035,7 @@ var Collection = class {
 };
 
 // src/query/query-builder.ts
+var import_core14 = require("@korajs/core");
 init_serializer();
 
 // src/query/pluralize.ts
@@ -2203,7 +2267,7 @@ var QueryBuilder = class _QueryBuilder {
     const relatedDef = this.schema?.collections[relatedCollection];
     if (!relatedDef) return;
     const placeholders = uniqueFks.map(() => "?").join(", ");
-    const sql = `SELECT * FROM ${relatedCollection} WHERE id IN (${placeholders}) AND _deleted = 0`;
+    const sql = `SELECT * FROM ${(0, import_core14.quoteIdent)(relatedCollection)} WHERE id IN (${placeholders}) AND _deleted = 0`;
     const rows = await this.adapter.query(sql, uniqueFks);
     const relatedRecords = rows.map((row) => deserializeRecord(row, relatedDef.fields));
     const lookup = /* @__PURE__ */ new Map();
@@ -2226,7 +2290,7 @@ var QueryBuilder = class _QueryBuilder {
     if (!relatedDef) return;
     const fkField = relation.field;
     const placeholders = primaryIds.map(() => "?").join(", ");
-    const sql = `SELECT * FROM ${relatedCollection} WHERE ${fkField} IN (${placeholders}) AND _deleted = 0`;
+    const sql = `SELECT * FROM ${(0, import_core14.quoteIdent)(relatedCollection)} WHERE ${(0, import_core14.quoteIdent)(fkField)} IN (${placeholders}) AND _deleted = 0`;
     const rows = await this.adapter.query(sql, primaryIds);
     const relatedRecords = rows.map((row) => deserializeRecord(row, relatedDef.fields));
     const grouped = /* @__PURE__ */ new Map();
@@ -2268,7 +2332,7 @@ var QueryError2 = class extends Error {
 };
 
 // src/relations/relation-enforcer.ts
-var import_core12 = require("@korajs/core");
+var import_core15 = require("@korajs/core");
 init_serializer();
 
 // src/relations/relation-lookup.ts
@@ -2293,7 +2357,7 @@ function getIncomingRelations(lookup, collection) {
 }
 
 // src/relations/relation-enforcer.ts
-var ReferentialIntegrityError = class extends import_core12.KoraError {
+var ReferentialIntegrityError = class extends import_core15.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.`,
@@ -2372,7 +2436,7 @@ var RelationEnforcer = class {
   async enforceCascade(incoming, deletedRecordId, tx, causalDeps) {
     const { sourceCollection, foreignKeyField } = incoming;
     const referencingRows = await tx.query(
-      `SELECT id FROM ${sourceCollection} WHERE ${foreignKeyField} = ? AND _deleted = 0`,
+      `SELECT id FROM ${(0, import_core15.quoteIdent)(sourceCollection)} WHERE ${(0, import_core15.quoteIdent)(foreignKeyField)} = ? AND _deleted = 0`,
       [deletedRecordId]
     );
     if (referencingRows.length === 0) {
@@ -2382,7 +2446,7 @@ var RelationEnforcer = class {
     for (const row of referencingRows) {
       const now = Date.now();
       const sequenceNumber = await allocateNextSequenceInTransaction(tx, this.nodeId);
-      const operation = await (0, import_core12.createOperation)(
+      const operation = await (0, import_core15.createOperation)(
         {
           nodeId: this.nodeId,
           type: "delete",
@@ -2419,7 +2483,7 @@ var RelationEnforcer = class {
       return [];
     }
     const referencingRows = await tx.query(
-      `SELECT id FROM ${sourceCollection} WHERE ${foreignKeyField} = ? AND _deleted = 0`,
+      `SELECT id FROM ${(0, import_core15.quoteIdent)(sourceCollection)} WHERE ${(0, import_core15.quoteIdent)(foreignKeyField)} = ? AND _deleted = 0`,
       [deletedRecordId]
     );
     if (referencingRows.length === 0) {
@@ -2431,7 +2495,7 @@ var RelationEnforcer = class {
       const sequenceNumber = await allocateNextSequenceInTransaction(tx, this.nodeId);
       const updateData = { [foreignKeyField]: null };
       const previousData = { [foreignKeyField]: deletedRecordId };
-      const operation = await (0, import_core12.createOperation)(
+      const operation = await (0, import_core15.createOperation)(
         {
           nodeId: this.nodeId,
           type: "update",
@@ -2467,7 +2531,7 @@ var RelationEnforcer = class {
   async enforceRestrict(incoming, deletedRecordId, tx) {
     const { sourceCollection, foreignKeyField, relationName } = incoming;
     const countRows = await tx.query(
-      `SELECT COUNT(*) as cnt FROM ${sourceCollection} WHERE ${foreignKeyField} = ? AND _deleted = 0`,
+      `SELECT COUNT(*) as cnt FROM ${(0, import_core15.quoteIdent)(sourceCollection)} WHERE ${(0, import_core15.quoteIdent)(foreignKeyField)} = ? AND _deleted = 0`,
       [deletedRecordId]
     );
     const count = countRows[0]?.cnt ?? 0;
@@ -2492,7 +2556,7 @@ var RelationEnforcer = class {
 };
 
 // src/replay/replay-to.ts
-var import_core13 = require("@korajs/core");
+var import_core16 = require("@korajs/core");
 var import_internal = require("@korajs/core/internal");
 init_op_data_encoding();
 function collectCausalClosure(allOps, targetOperationId) {
@@ -2502,7 +2566,7 @@ function collectCausalClosure(allOps, targetOperationId) {
   }
   const target = opMap.get(targetOperationId);
   if (!target) {
-    throw new import_core13.OperationError(
+    throw new import_core16.OperationError(
       `Operation "${targetOperationId}" not found in the local operation log`,
       {
         operationId: targetOperationId
@@ -2534,7 +2598,7 @@ function buildReplaySnapshot(schema, allOps, targetOperationId) {
   const operationsApplied = collectCausalClosure(allOps, targetOperationId);
   const targetOperation = operationsApplied.find((op) => op.id === targetOperationId);
   if (!targetOperation) {
-    throw new import_core13.OperationError(`Operation "${targetOperationId}" not found after causal sort`, {
+    throw new import_core16.OperationError(`Operation "${targetOperationId}" not found after causal sort`, {
       operationId: targetOperationId
     });
   }
@@ -2660,7 +2724,7 @@ function toCollectionRecord(record, definition) {
 }
 
 // src/sequences/sequence-manager.ts
-var import_core14 = require("@korajs/core");
+var import_core17 = require("@korajs/core");
 var SequenceManager = class {
   adapter;
   nodeId;
@@ -2678,7 +2742,7 @@ var SequenceManager = class {
   async next(name, config) {
     const scope = config?.scope ?? "";
     const startAt = config?.startAt ?? 1;
-    const format = config?.format ?? (0, import_core14.defaultSequenceFormat)(name);
+    const format = config?.format ?? (0, import_core17.defaultSequenceFormat)(name);
     let counter = 0;
     await this.adapter.transaction(async (tx) => {
       const rows = await tx.query(
@@ -2700,7 +2764,7 @@ var SequenceManager = class {
         );
       }
     });
-    return (0, import_core14.formatSequenceValue)(format, counter, this.nodeId);
+    return (0, import_core17.formatSequenceValue)(format, counter, this.nodeId);
   }
   /**
    * Get the current counter value without incrementing.
@@ -3159,10 +3223,10 @@ var SubscriptionManager = class {
 };
 
 // src/sync/rebase-unsynced-operations.ts
-var import_core15 = require("@korajs/core");
+var import_core18 = require("@korajs/core");
 var import_internal2 = require("@korajs/core/internal");
 init_serializer();
-var LOGICAL_COUNTER_LIMIT = import_core15.MAX_LOGICAL + 1;
+var LOGICAL_COUNTER_LIMIT = import_core18.MAX_LOGICAL + 1;
 function emptyResult() {
   return { operations: [], idMapping: {}, rebasedCount: 0, newMaxTimestamp: null };
 }
@@ -3174,7 +3238,9 @@ async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, cor
   const rebased = [];
   let maxOtherSerializedTs = null;
   for (const collectionName of Object.keys(schema.collections)) {
-    const rows = await adapter.query(`SELECT * FROM _kora_ops_${collectionName}`);
+    const rows = await adapter.query(
+      `SELECT * FROM ${(0, import_core18.quoteIdent)(`_kora_ops_${collectionName}`)}`
+    );
     for (const row of rows) {
       if (rebaseIds.has(row.id)) {
         rebased.push(deserializeOperationWithCollection(row, collectionName));
@@ -3186,9 +3252,9 @@ async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, cor
   if (rebased.length === 0) {
     return emptyResult();
   }
-  const maxOtherWallTime = maxOtherSerializedTs === null ? Number.NEGATIVE_INFINITY : import_core15.HybridLogicalClock.deserialize(maxOtherSerializedTs).wallTime;
+  const maxOtherWallTime = maxOtherSerializedTs === null ? Number.NEGATIVE_INFINITY : import_core18.HybridLogicalClock.deserialize(maxOtherSerializedTs).wallTime;
   const baseWallTime = Math.max(correctedNowMs, maxOtherWallTime + 1);
-  rebased.sort((a, b) => import_core15.HybridLogicalClock.compare(a.timestamp, b.timestamp));
+  rebased.sort((a, b) => import_core18.HybridLogicalClock.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.
@@ -3216,7 +3282,7 @@ async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, cor
       schemaVersion: op.schemaVersion,
       ...op.atomicOps !== void 0 ? { atomicOps: op.atomicOps } : {}
     };
-    const newId = await (0, import_internal2.computeOperationId)(input, import_core15.HybridLogicalClock.serialize(ts));
+    const newId = await (0, import_internal2.computeOperationId)(input, import_core18.HybridLogicalClock.serialize(ts));
     idMapping[op.id] = newId;
     newIds.push(newId);
   }
@@ -3243,7 +3309,7 @@ async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, cor
         continue;
       }
       const opsTable = `_kora_ops_${oldOp.collection}`;
-      await tx.execute(`DELETE FROM ${opsTable} WHERE id = ?`, [oldOp.id]);
+      await tx.execute(`DELETE FROM ${(0, import_core18.quoteIdent)(opsTable)} WHERE id = ?`, [oldOp.id]);
       const opInsert = buildInsertQuery(
         opsTable,
         serializeOperation(newOp)
@@ -3252,11 +3318,11 @@ async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, cor
       const oldVersion = serializeRowVersion(oldOp.timestamp);
       const newVersion = serializeRowVersion(newOp.timestamp);
       await tx.execute(
-        `UPDATE ${oldOp.collection} SET _version = ?, _updated_at = ? WHERE id = ? AND _version = ?`,
+        `UPDATE ${(0, import_core18.quoteIdent)(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 = ?`,
+        `SELECT _field_versions FROM ${(0, import_core18.quoteIdent)(oldOp.collection)} WHERE id = ?`,
         [oldOp.recordId]
       );
       const fieldVersions = parseFieldVersions(rows[0]?._field_versions);
@@ -3268,14 +3334,14 @@ async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, cor
         }
       }
       if (changed) {
-        await tx.execute(`UPDATE ${oldOp.collection} SET _field_versions = ? WHERE id = ?`, [
-          serializeFieldVersions(fieldVersions),
-          oldOp.recordId
-        ]);
+        await tx.execute(
+          `UPDATE ${(0, import_core18.quoteIdent)(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 = ?`,
+          `UPDATE ${(0, import_core18.quoteIdent)(oldOp.collection)} SET _created_at = ? WHERE id = ? AND _created_at = ?`,
           [newOp.timestamp.wallTime, oldOp.recordId, oldOp.timestamp.wallTime]
         );
       }
@@ -3291,7 +3357,7 @@ async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, cor
 }
 
 // src/transaction/transaction-context.ts
-var import_core16 = require("@korajs/core");
+var import_core19 = require("@korajs/core");
 init_op_data_encoding();
 init_serializer();
 var TransactionContext = class {
@@ -3303,7 +3369,7 @@ var TransactionContext = class {
   config;
   constructor(config) {
     this.config = config;
-    this.transactionId = (0, import_core16.generateUUIDv7)();
+    this.transactionId = (0, import_core19.generateUUIDv7)();
   }
   /**
    * Set a human-readable mutation name for this transaction.
@@ -3418,8 +3484,8 @@ var TransactionContext = class {
   }
   async insert(collectionName, definition, data) {
     this.ensureActive();
-    const validated = (0, import_core16.validateRecord)(collectionName, definition, data, "insert");
-    const recordId = (0, import_core16.generateUUIDv7)();
+    const validated = (0, import_core19.validateRecord)(collectionName, definition, data, "insert");
+    const recordId = (0, import_core19.generateUUIDv7)();
     const now = Date.now();
     for (const [fieldName, descriptor] of Object.entries(definition.fields)) {
       if (descriptor.auto && descriptor.kind === "timestamp") {
@@ -3428,7 +3494,7 @@ var TransactionContext = class {
     }
     const sequenceNumber = await this.config.sequenceAllocator.allocate();
     const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
-    const operation = await (0, import_core16.createOperation)(
+    const operation = await (0, import_core19.createOperation)(
       {
         nodeId: this.config.nodeId,
         type: "insert",
@@ -3483,7 +3549,7 @@ var TransactionContext = class {
     if (!currentRecord) {
       throw new RecordNotFoundError(collectionName, id);
     }
-    const validated = (0, import_core16.validateRecord)(collectionName, definition, data, "update");
+    const validated = (0, import_core19.validateRecord)(collectionName, definition, data, "update");
     const now = Date.now();
     const previousData = {};
     const resolvedData = {};
@@ -3491,9 +3557,9 @@ var TransactionContext = class {
     for (const key of Object.keys(validated)) {
       const value = validated[key];
       previousData[key] = currentRecord[key];
-      if ((0, import_core16.isAtomicOp)(value)) {
-        resolvedData[key] = (0, import_core16.resolveAtomicOp)(currentRecord[key], value);
-        atomicOps[key] = (0, import_core16.toAtomicOp)(value);
+      if ((0, import_core19.isAtomicOp)(value)) {
+        resolvedData[key] = (0, import_core19.resolveAtomicOp)(currentRecord[key], value);
+        atomicOps[key] = (0, import_core19.toAtomicOp)(value);
       } else {
         resolvedData[key] = value;
       }
@@ -3501,7 +3567,7 @@ var TransactionContext = class {
     const hasAtomicOps = Object.keys(atomicOps).length > 0;
     const sequenceNumber = await this.config.sequenceAllocator.allocate();
     const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
-    const operation = await (0, import_core16.createOperation)(
+    const operation = await (0, import_core19.createOperation)(
       {
         nodeId: this.config.nodeId,
         type: "update",
@@ -3556,7 +3622,7 @@ var TransactionContext = class {
     const now = Date.now();
     const sequenceNumber = await this.config.sequenceAllocator.allocate();
     const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
-    const operation = await (0, import_core16.createOperation)(
+    const operation = await (0, import_core19.createOperation)(
       {
         nodeId: this.config.nodeId,
         type: "delete",
@@ -3606,7 +3672,7 @@ var TransactionContext = class {
       }
     }
     const rows = await this.config.adapter.query(
-      `SELECT * FROM ${collectionName} WHERE id = ? AND _deleted = 0`,
+      `SELECT * FROM ${(0, import_core19.quoteIdent)(collectionName)} WHERE id = ? AND _deleted = 0`,
       [id]
     );
     let record = rows[0] ? deserializeRecord(rows[0], definition.fields) : null;
@@ -3661,7 +3727,7 @@ var TransactionSequenceAllocator = class {
 };
 
 // src/store/tab-node-id.ts
-var import_core17 = require("@korajs/core");
+var import_core20 = require("@korajs/core");
 function perTabStorageKey(dbName) {
   return `kora-tab-node-${dbName}`;
 }
@@ -3682,7 +3748,7 @@ function resolvePerTabNodeId(dbName) {
   if (existing) {
     return existing;
   }
-  const nodeId = (0, import_core17.generateUUIDv7)();
+  const nodeId = (0, import_core20.generateUUIDv7)();
   savePerTabNodeId(dbName, nodeId);
   return nodeId;
 }
@@ -3692,7 +3758,7 @@ var Store = class {
   opened = false;
   nodeId = "";
   sequenceNumber = 0;
-  versionVector = (0, import_core19.createVersionVector)();
+  versionVector = (0, import_core23.createVersionVector)();
   clock = null;
   collections = /* @__PURE__ */ new Map();
   subscriptionManager;
@@ -3728,8 +3794,8 @@ var Store = class {
     await this.adapter.open(this.schema);
     await this.runMigrationsIfNeeded();
     this.nodeId = await this.loadOrGenerateNodeId();
-    this.clock = new import_core19.HybridLogicalClock(this.nodeId);
-    this.causalTracker = new import_core19.CausalTracker();
+    this.clock = new import_core23.HybridLogicalClock(this.nodeId);
+    this.causalTracker = new import_core23.CausalTracker();
     this.sequenceManager = new SequenceManager(this.adapter, this.nodeId);
     this.sequenceNumber = await this.loadSequenceNumber();
     this.versionVector = await this.loadVersionVector();
@@ -3841,7 +3907,7 @@ var Store = class {
       return "skipped";
     }
     const existing = await this.adapter.query(
-      `SELECT id FROM _kora_ops_${collection} WHERE id = ?`,
+      `SELECT id FROM ${(0, import_core23.quoteIdent)(`_kora_ops_${collection}`)} WHERE id = ?`,
       [op.id]
     );
     if (existing.length > 0) {
@@ -3866,7 +3932,8 @@ var Store = class {
           throw new OptimisticLockError(collection, op.recordId);
         }
       };
-      if (op.type === "insert" && materializeSource) {
+      if (options?.logOnly) {
+      } else if (op.type === "insert" && materializeSource) {
         const serializedData = serializeRecord(materializeSource, definition.fields);
         const existing2 = await tx.query(
           `SELECT _updated_at, _version, _field_versions, _deleted FROM ${collection} WHERE id = ?`,
@@ -3888,7 +3955,7 @@ var Store = class {
           };
           const insertQuery = buildInsertQuery(collection, record);
           await tx.execute(insertQuery.sql, insertQuery.params);
-          await this.foldOrphanedOperations(tx, collection, definition, op.recordId);
+          await this.foldOrphanedOperations(tx, collection, definition, op.recordId, op);
         } else if (row._deleted === 1) {
           if (isIncomingNewerThanRow(materializeTimestamp, row)) {
             const fieldChanges = {
@@ -3946,7 +4013,7 @@ var Store = class {
         const serializedChanges = serializeRecord(materializeSource, definition.fields);
         const changedFields = Object.keys(serializedChanges);
         const currentRows = await tx.query(
-          `SELECT _version, _field_versions FROM ${collection} WHERE id = ?`,
+          `SELECT _version, _field_versions FROM ${(0, import_core23.quoteIdent)(collection)} WHERE id = ?`,
           [op.recordId]
         );
         const currentRow = currentRows[0];
@@ -4040,22 +4107,22 @@ var Store = class {
    * 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) {
+  async foldOrphanedOperations(tx, collection, definition, recordId, insertOp) {
     const orphanRows = await tx.query(
-      `SELECT * FROM _kora_ops_${collection} WHERE record_id = ? AND type IN ('update', 'delete')`,
+      `SELECT * FROM ${(0, import_core23.quoteIdent)(`_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) => import_core19.HybridLogicalClock.compare(a.timestamp, b.timestamp));
+    const orphans = orphanRows.map((r) => deserializeOperationWithCollection(r, collection)).sort((a, b) => import_core23.HybridLogicalClock.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 = ?`,
+          `SELECT _version, _field_versions FROM ${(0, import_core23.quoteIdent)(collection)} WHERE id = ?`,
           [recordId]
         );
         const current = rows[0];
@@ -4089,6 +4156,37 @@ var Store = class {
         await tx.execute(query.sql, query.params);
       }
     }
+    const atomicFields = /* @__PURE__ */ new Set();
+    for (const orphan of orphans) {
+      if (orphan.type === "update" && orphan.atomicOps) {
+        for (const field of Object.keys(orphan.atomicOps)) {
+          atomicFields.add(field);
+        }
+      }
+    }
+    if (atomicFields.size > 0) {
+      const ordered = [insertOp, ...orphans].sort(
+        (a, b) => import_core23.HybridLogicalClock.compare(a.timestamp, b.timestamp)
+      );
+      const folded = (0, import_core23.replayOperationsForRecord)(ordered);
+      if (folded) {
+        const composed = {};
+        for (const field of atomicFields) {
+          if (field in folded) {
+            composed[field] = folded[field];
+          }
+        }
+        const serialized = serializeRecord(composed, definition.fields);
+        const cols = Object.keys(serialized);
+        if (cols.length > 0) {
+          const setClause = cols.map((c) => `${(0, import_core23.quoteIdent)(c)} = ?`).join(", ");
+          await tx.execute(`UPDATE ${(0, import_core23.quoteIdent)(collection)} SET ${setClause} WHERE id = ?`, [
+            ...cols.map((c) => serialized[c]),
+            recordId
+          ]);
+        }
+      }
+    }
   }
   /**
    * Get operations from a node within a sequence number range.
@@ -4105,7 +4203,7 @@ var Store = class {
     const allOps = [];
     for (const collectionName of Object.keys(this.schema.collections)) {
       const rows = await this.adapter.query(
-        `SELECT * FROM _kora_ops_${collectionName} WHERE node_id = ? AND sequence_number >= ? AND sequence_number <= ? ORDER BY sequence_number ASC`,
+        `SELECT * FROM ${(0, import_core23.quoteIdent)(`_kora_ops_${collectionName}`)} WHERE node_id = ? AND sequence_number >= ? AND sequence_number <= ? ORDER BY sequence_number ASC`,
         [nodeId, fromSeq, toSeq]
       );
       for (const row of rows) {
@@ -4124,7 +4222,7 @@ var Store = class {
     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`
+        `SELECT * FROM ${(0, import_core23.quoteIdent)(`_kora_ops_${collectionName}`)} ORDER BY sequence_number ASC`
       );
       for (const row of rows) {
         allOps.push(deserializeOperationWithCollection(row, collectionName));
@@ -4193,6 +4291,22 @@ var Store = class {
       col.setMutationHandler(handler);
     }
   }
+  /**
+   * Notify this store that another same-origin runtime committed an operation to
+   * the shared local database. The operation has already been persisted and
+   * materialized by the database owner; this method only advances in-memory causal
+   * watermarks and invalidates local reactive queries so already-open tabs stay
+   * live without reapplying or rewriting the operation.
+   */
+  notifyExternalOperation(operation) {
+    this.ensureOpen();
+    const definition = this.schema.collections[operation.collection];
+    if (!definition) {
+      return;
+    }
+    this.recordOperationSequence(operation);
+    this.subscriptionManager.notify(operation.collection, operation);
+  }
   /**
    * Build mutation context for a collection (used by ApplyPipeline side effects).
    */
@@ -4234,7 +4348,7 @@ var Store = class {
       return null;
     }
     const rows = await this.adapter.query(
-      `SELECT * FROM ${collection} WHERE id = ?`,
+      `SELECT * FROM ${(0, import_core23.quoteIdent)(collection)} WHERE id = ?`,
       [recordId]
     );
     const row = rows[0];
@@ -4259,7 +4373,7 @@ var Store = class {
       return null;
     }
     const rows = await this.adapter.query(
-      `SELECT _version, _field_versions FROM ${collection} WHERE id = ?`,
+      `SELECT _version, _field_versions FROM ${(0, import_core23.quoteIdent)(collection)} WHERE id = ?`,
       [recordId]
     );
     const row = rows[0];
@@ -4302,6 +4416,35 @@ var Store = class {
     this.ensureOpen();
     await saveDeltaCursor(this.adapter, cursor);
   }
+  /**
+   * Load the persisted delivery watermark for a view signature (0 when none recorded).
+   * Defaults to the unfiltered view so existing single-watermark reads keep working.
+   */
+  async loadDeliveryWatermark(signature = "") {
+    this.ensureOpen();
+    return loadDeliveryWatermark(this.adapter, signature);
+  }
+  /**
+   * Persist the delivery watermark for a view signature so it survives a client restart.
+   */
+  async saveDeliveryWatermark(signature, watermark) {
+    this.ensureOpen();
+    await saveDeliveryWatermark(this.adapter, signature, watermark);
+  }
+  /**
+   * Load every persisted view watermark, keyed by signature.
+   */
+  async loadAllDeliveryWatermarks() {
+    this.ensureOpen();
+    return loadAllDeliveryWatermarks(this.adapter);
+  }
+  /**
+   * Delete a persisted view watermark (safe: the view back-fills from 0 when next visited).
+   */
+  async deleteDeliveryWatermark(signature) {
+    this.ensureOpen();
+    await deleteDeliveryWatermark(this.adapter, signature);
+  }
   /**
    * Local operations not yet reflected on the server version vector.
    */
@@ -4351,7 +4494,7 @@ var Store = class {
   async compact(strategy) {
     this.ensureOpen();
     if (strategy.mode === "never") {
-      return compactOperationLog(this.adapter, this.schema, strategy, (0, import_core19.createVersionVector)());
+      return compactOperationLog(this.adapter, this.schema, strategy, (0, import_core23.createVersionVector)());
     }
     const serverVector = strategy.serverVector ?? await loadLastAckedServerVector(this.adapter);
     return compactOperationLog(this.adapter, this.schema, strategy, serverVector);
@@ -4365,7 +4508,7 @@ var Store = class {
   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`,
+      `SELECT * FROM ${(0, import_core23.quoteIdent)(`_kora_ops_${collection}`)} WHERE node_id = ? AND record_id = ? ORDER BY sequence_number DESC LIMIT 1`,
       [this.nodeId, recordId]
     );
     const row = rows[0];
@@ -4380,18 +4523,33 @@ var Store = class {
   async getLatestOperationForRecord(collection, recordId) {
     this.ensureOpen();
     const rows = await this.adapter.query(
-      `SELECT * FROM _kora_ops_${collection} WHERE record_id = ?`,
+      `SELECT * FROM ${(0, import_core23.quoteIdent)(`_kora_ops_${collection}`)} WHERE record_id = ?`,
       [recordId]
     );
     let latest = null;
     for (const row of rows) {
       const op = deserializeOperationWithCollection(row, collection);
-      if (!latest || import_core19.HybridLogicalClock.compare(op.timestamp, latest.timestamp) > 0) {
+      if (!latest || import_core23.HybridLogicalClock.compare(op.timestamp, latest.timestamp) > 0) {
         latest = op;
       }
     }
     return latest;
   }
+  /**
+   * All operations for a record, sorted in HLC total order (wallTime, logical,
+   * nodeId). Used by the apply pipeline to materialize atomic-op fields by folding
+   * the record's log, matching the server's materialization exactly.
+   */
+  async getOperationsForRecord(collection, recordId) {
+    this.ensureOpen();
+    const rows = await this.adapter.query(
+      `SELECT * FROM ${(0, import_core23.quoteIdent)(`_kora_ops_${collection}`)} WHERE record_id = ?`,
+      [recordId]
+    );
+    const ops = rows.map((row) => deserializeOperationWithCollection(row, collection));
+    ops.sort((a, b) => import_core23.HybridLogicalClock.compare(a.timestamp, b.timestamp));
+    return ops;
+  }
   /** Expose the subscription manager for direct access (e.g., by QueryBuilder) */
   getSubscriptionManager() {
     return this.subscriptionManager;
@@ -4529,7 +4687,7 @@ var Store = class {
     for (let v = storedVersion + 1; v <= targetVersion; v++) {
       const migration = migrations[v];
       if (!migration) continue;
-      const sqlStatements = (0, import_core19.migrationStepsToSQL)(migration.steps);
+      const sqlStatements = (0, import_core23.migrationStepsToSQL)(migration.steps);
       for (const sql of sqlStatements) {
         try {
           await this.adapter.execute(sql);
@@ -4567,14 +4725,14 @@ var Store = class {
    */
   async runBackfill(collection, transform) {
     const rows = await this.adapter.query(
-      `SELECT * FROM ${collection} WHERE _deleted = 0`
+      `SELECT * FROM ${(0, import_core23.quoteIdent)(collection)} WHERE _deleted = 0`
     );
     await this.adapter.transaction(async (tx) => {
       for (const row of rows) {
         const updates = transform(row);
         const fields = Object.keys(updates);
         if (fields.length === 0) continue;
-        const setClauses = fields.map((f) => `${f} = ?`).join(", ");
+        const setClauses = fields.map((f) => `${(0, import_core23.quoteIdent)(f)} = ?`).join(", ");
         const values = fields.map((f) => {
           const val = updates[f];
           if (typeof val === "boolean") return val ? 1 : 0;
@@ -4584,7 +4742,7 @@ var Store = class {
           return val;
         });
         values.push(row.id);
-        await tx.execute(`UPDATE ${collection} SET ${setClauses} WHERE id = ?`, values);
+        await tx.execute(`UPDATE ${(0, import_core23.quoteIdent)(collection)} SET ${setClauses} WHERE id = ?`, values);
       }
     });
   }
@@ -4607,7 +4765,7 @@ var Store = class {
     if (rows[0]) {
       return rows[0].value;
     }
-    const newNodeId = (0, import_core19.generateUUIDv7)();
+    const newNodeId = (0, import_core23.generateUUIDv7)();
     await this.adapter.execute("INSERT INTO _kora_meta (key, value) VALUES ('node_id', ?)", [
       newNodeId
     ]);
@@ -4624,7 +4782,7 @@ var Store = class {
     const rows = await this.adapter.query(
       "SELECT node_id, sequence_number FROM _kora_version_vector"
     );
-    const vector = (0, import_core19.createVersionVector)();
+    const vector = (0, import_core23.createVersionVector)();
     for (const row of rows) {
       vector.set(row.node_id, row.sequence_number);
     }
@@ -4644,6 +4802,7 @@ var QueryStore = class {
   listeners = /* @__PURE__ */ new Set();
   unsubscribeQuery = null;
   active = false;
+  hasEmittedSnapshot = false;
   queryBuilder;
   constructor(queryBuilder) {
     this.queryBuilder = queryBuilder;
@@ -4669,16 +4828,25 @@ var QueryStore = class {
   getSnapshot = () => {
     return this.snapshot;
   };
+  /**
+   * Whether the underlying query subscription has delivered at least one
+   * authoritative result for the current subscription lifecycle.
+   */
+  hasSnapshot = () => {
+    return this.hasEmittedSnapshot;
+  };
   /** Tear down listeners and the underlying query subscription. */
   destroy() {
     this.stopSubscription();
     this.listeners.clear();
     this.snapshot = EMPTY_ARRAY;
+    this.hasEmittedSnapshot = false;
   }
   startSubscription() {
     this.active = true;
     this.unsubscribeQuery = this.queryBuilder.subscribe((results) => {
       if (!this.active) return;
+      this.hasEmittedSnapshot = true;
       this.snapshot = Object.freeze([...results]);
       this.notifyListeners();
     });
@@ -4698,12 +4866,12 @@ var QueryStore = class {
 };
 
 // src/reactivity/assert-query-ready.ts
-var import_core20 = require("@korajs/core");
+var import_core24 = require("@korajs/core");
 var LEGACY_PENDING_COLLECTION = "__pending__";
 function assertQueryReady(query) {
   const descriptor = query.getDescriptor();
   if (descriptor.collection === LEGACY_PENDING_COLLECTION) {
-    throw new import_core20.AppNotReadyError(
+    throw new import_core24.AppNotReadyError(
       "Cannot use useQuery() before app.ready. Await app.ready or wrap your UI in <KoraProvider app={app}>."
     );
   }
@@ -5126,7 +5294,7 @@ init_audit_json();
 init_export_audit();
 
 // src/blob/content-addressed-blob-store.ts
-var import_core21 = require("@korajs/core");
+var import_core25 = require("@korajs/core");
 var BlobIntegrityError = class extends Error {
   constructor(expectedHash, actualHash) {
     super(`Blob integrity check failed: content under hash ${expectedHash} hashes to ${actualHash}`);
@@ -5140,7 +5308,7 @@ var BlobIntegrityError = class extends Error {
 var MemoryBlobStore = class {
   blobs = /* @__PURE__ */ new Map();
   async put(bytes, metadata = {}) {
-    const ref = await (0, import_core21.createBlobRef)(bytes, metadata);
+    const ref = await (0, import_core25.createBlobRef)(bytes, metadata);
     if (!this.blobs.has(ref.hash)) {
       const stored = new Uint8Array(bytes.byteLength);
       stored.set(bytes);
@@ -5153,7 +5321,7 @@ var MemoryBlobStore = class {
     if (stored === void 0) {
       return null;
     }
-    const actualHash = await (0, import_core21.hashBlob)(stored);
+    const actualHash = await (0, import_core25.hashBlob)(stored);
     if (actualHash !== hash) {
       throw new BlobIntegrityError(hash, actualHash);
     }
@@ -5176,7 +5344,7 @@ var MemoryBlobStore = class {
 };
 
 // src/blob/opfs-blob-store.ts
-var import_core22 = require("@korajs/core");
+var import_core26 = require("@korajs/core");
 var OpfsBlobStore = class {
   constructor(dir) {
     this.dir = dir;
@@ -5186,7 +5354,7 @@ var OpfsBlobStore = class {
     return hash.slice(0, 2);
   }
   async put(bytes, metadata = {}) {
-    const ref = await (0, import_core22.createBlobRef)(bytes, metadata);
+    const ref = await (0, import_core26.createBlobRef)(bytes, metadata);
     const shard = this.shardFor(ref.hash);
     if (await this.dir.has(shard, ref.hash)) {
       return ref;
@@ -5201,7 +5369,7 @@ var OpfsBlobStore = class {
     if (bytes === null) {
       return null;
     }
-    const actual = await (0, import_core22.hashBlob)(bytes);
+    const actual = await (0, import_core26.hashBlob)(bytes);
     if (actual !== hash) {
       throw new BlobIntegrityError(hash, actual);
     }
@@ -5347,7 +5515,7 @@ async function createOpfsBlobStore(rootDirName = "kora-blobs") {
 }
 
 // src/blob/blob-chunking.ts
-var import_core23 = require("@korajs/core");
+var import_core27 = require("@korajs/core");
 var DEFAULT_CHUNK_SIZE = 256 * 1024;
 async function chunkBlob(bytes, chunkSize = DEFAULT_CHUNK_SIZE, metadata = {}) {
   if (chunkSize <= 0) {
@@ -5359,13 +5527,13 @@ async function chunkBlob(bytes, chunkSize = DEFAULT_CHUNK_SIZE, metadata = {}) {
     const end = Math.min(offset + chunkSize, bytes.byteLength);
     const chunk = new Uint8Array(end - offset);
     chunk.set(bytes.subarray(offset, end));
-    const hash = await (0, import_core23.hashBlob)(chunk);
+    const hash = await (0, import_core27.hashBlob)(chunk);
     chunkHashes.push(hash);
     if (!chunks.has(hash)) {
       chunks.set(hash, chunk);
     }
   }
-  const blobHash = await (0, import_core23.hashBlob)(bytes);
+  const blobHash = await (0, import_core27.hashBlob)(bytes);
   const manifest = {
     blobHash,
     size: bytes.byteLength,
@@ -5397,7 +5565,7 @@ async function reassembleBlob(manifest, chunkStore) {
     out.set(part, offset);
     offset += part.byteLength;
   }
-  const actual = await (0, import_core23.hashBlob)(out);
+  const actual = await (0, import_core27.hashBlob)(out);
   if (actual !== manifest.blobHash) {
     throw new BlobIntegrityError(manifest.blobHash, actual);
   }
@@ -5405,7 +5573,7 @@ async function reassembleBlob(manifest, chunkStore) {
 }
 
 // src/blob/blob-transfer.ts
-var import_core24 = require("@korajs/core");
+var import_core28 = require("@korajs/core");
 async function receiveBlob(manifest, provider, stores) {
   let chunksFetched = 0;
   let chunksSkipped = 0;
@@ -5423,7 +5591,7 @@ async function receiveBlob(manifest, provider, stores) {
     if (bytes === null) {
       throw new Error(`Blob transfer failed: provider could not supply chunk ${hash}`);
     }
-    const actual = await (0, import_core24.hashBlob)(bytes);
+    const actual = await (0, import_core28.hashBlob)(bytes);
     if (actual !== hash) {
       throw new BlobIntegrityError(hash, actual);
     }
@@ -5452,7 +5620,7 @@ async function prepareBlobForSend(bytes, chunkStore, options = {}) {
 }
 
 // src/blob/blob-manifest-transfer.ts
-var import_core25 = require("@korajs/core");
+var import_core29 = require("@korajs/core");
 function serializeBlobManifest(manifest) {
   const canonical = {
     blobHash: manifest.blobHash,
@@ -5517,7 +5685,7 @@ async function fetchBlobManifest(provider, manifestHash) {
   if (bytes === null) {
     throw new Error(`Blob manifest ${manifestHash} could not be fetched from the provider`);
   }
-  const actual = await (0, import_core25.hashBlob)(bytes);
+  const actual = await (0, import_core29.hashBlob)(bytes);
   if (actual !== manifestHash) {
     throw new BlobIntegrityError(manifestHash, actual);
   }
@@ -5533,12 +5701,12 @@ async function resolveBlobManifest(provider, ref) {
 }
 
 // src/blob/server-blob-callbacks.ts
-var import_core26 = require("@korajs/core");
+var import_core30 = require("@korajs/core");
 function toServerBlobCallbacks(store) {
   return {
     resolveBlobChunk: (hash) => store.get(hash),
     async persistBlobChunk(hash, bytes) {
-      const actual = await (0, import_core26.hashBlob)(bytes);
+      const actual = await (0, import_core30.hashBlob)(bytes);
       if (actual !== hash) {
         return;
       }
@@ -5552,11 +5720,11 @@ function createMemoryServerBlobStore() {
 }
 
 // src/blob/blob-gc.ts
-var import_core27 = require("@korajs/core");
+var import_core31 = require("@korajs/core");
 function extractBlobRefs(record) {
   const refs = [];
   for (const value of Object.values(record)) {
-    if ((0, import_core27.isBlobRef)(value)) {
+    if ((0, import_core31.isBlobRef)(value)) {
       refs.push(value);
     }
   }
@@ -5601,7 +5769,7 @@ async function collectBlobGarbage(store, liveRefs, options = {}) {
 }
 
 // src/blob/blob-chunk-transport.ts
-var import_core28 = require("@korajs/core");
+var import_core32 = require("@korajs/core");
 function createRemoteChunkProvider(port, options = {}) {
   const timeoutMs = options.timeoutMs ?? 3e4;
   const pending = /* @__PURE__ */ new Map();
@@ -5620,7 +5788,7 @@ function createRemoteChunkProvider(port, options = {}) {
   return {
     pendingCount: () => pending.size,
     getChunk(hash) {
-      const requestId = (0, import_core28.generateUUIDv7)();
+      const requestId = (0, import_core32.generateUUIDv7)();
       return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
           pending.delete(requestId);
@@ -5686,6 +5854,7 @@ function createChunkPortPair() {
   InvalidStateTransitionError,
   LAST_ACKED_SERVER_VECTOR_META_KEY,
   MemoryBlobStore,
+  NoLeaderError,
   OpfsBlobStore,
   OptimisticLockError,
   PersistenceError,