@korajs/store 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/index.js

@@ -2,10 +2,14 @@ import {
   decodeAuditExport,
   readAuditExportManifest,
   verifyAuditExportChecksum
-} from "./chunk-EIVXWF4B.js";
+} from "./chunk-CYO3YKFL.js";
 import {
   persistedAuditTraceFromEvent
 } from "./chunk-MYSJN3DF.js";
+import {
+  BlobIntegrityError,
+  MemoryBlobStore
+} from "./chunk-W4MTTNEZ.js";
 import {
   InvalidStateTransitionError,
   allocateNextSequenceInTransaction,
@@ -29,9 +33,10 @@ import {
   serializeRowVersion,
   validateStateTransition,
   validateUpdateStateMachine
-} from "./chunk-OUQDC5Z6.js";
+} from "./chunk-YT7MRFCP.js";
 import {
   AdapterError,
+  NoLeaderError,
   OptimisticLockError,
   PersistenceError,
   QueryError,
@@ -39,13 +44,13 @@ import {
   StoreNotOpenError,
   WorkerInitError,
   WorkerTimeoutError
-} from "./chunk-QL2XVZRN.js";
+} from "./chunk-TUR7RGEP.js";
 import {
   exportBackup,
   readBackupManifest,
   restoreBackup,
   verifyBackupChecksum
-} from "./chunk-5R4QMY3Z.js";
+} from "./chunk-HS6DBMST.js";
 import {
   decodeRichtext,
   decodeRichtextFieldsFromOpData,
@@ -57,13 +62,13 @@ import {
   richtextToPlainText,
   serializeOperation,
   serializeRecord
-} from "./chunk-ETDJEH2I.js";
+} from "./chunk-GSJ7EEUC.js";
 
 // src/compaction/types.ts
 var COMPACTION_BASELINE_META_KEY = "compaction_baseline_at";
 
 // src/compaction/compact-operation-log.ts
-import { HybridLogicalClock, createVersionVector } from "@korajs/core";
+import { HybridLogicalClock, createVersionVector, quoteIdent } from "@korajs/core";
 function computeAckCompactionWatermark(serverVector) {
   const watermark = createVersionVector();
   for (const [nodeId, seq] of serverVector) {
@@ -91,7 +96,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 = quoteIdent(`_kora_ops_${collectionName}`);
       for (const [nodeId, maxSeq] of watermark) {
         if (maxSeq <= 0) continue;
         const countSql = buildCountSql(table, ageCutoffSerialized !== null);
@@ -126,6 +131,7 @@ function buildDeleteSql(table, withAge) {
 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";
+var DELIVERY_WATERMARK_META_KEY = "delivery_watermark";
 function serializeVersionVectorToMeta(vector) {
   const record = {};
   for (const [nodeId, seq] of vector) {
@@ -198,6 +204,45 @@ 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
 import {
@@ -205,12 +250,15 @@ import {
   HybridLogicalClock as HybridLogicalClock3,
   createVersionVector as createVersionVector3,
   generateUUIDv7 as generateUUIDv73,
-  migrationStepsToSQL
+  migrationStepsToSQL,
+  quoteIdent as quoteIdent7,
+  replayOperationsForRecord
 } from "@korajs/core";
 
 // src/collection/collection.ts
+import { quoteIdent as quoteIdent2 } from "@korajs/core";
 var Collection = class {
-  constructor(name, definition, schema, adapter, clock, nodeId, allocateSequenceNumber, onMutation, relationEnforcer, mutationHandler, causalTracker) {
+  constructor(name, definition, schema, adapter, clock, nodeId, allocateSequenceNumber, onMutation, relationEnforcer, mutationHandler, causalTracker, secretKeyProvider) {
     this.name = name;
     this.definition = definition;
     this.schema = schema;
@@ -222,6 +270,7 @@ var Collection = class {
     this.relationEnforcer = relationEnforcer;
     this.mutationHandler = mutationHandler;
     this.causalTracker = causalTracker;
+    this.secretKeyProvider = secretKeyProvider;
   }
   name;
   definition;
@@ -234,6 +283,7 @@ var Collection = class {
   relationEnforcer;
   mutationHandler;
   causalTracker;
+  secretKeyProvider;
   mutationContext() {
     return {
       collection: this.name,
@@ -246,7 +296,8 @@ var Collection = class {
       onMutation: this.onMutation,
       relationEnforcer: this.relationEnforcer,
       causalTracker: this.causalTracker,
-      inTransaction: false
+      inTransaction: false,
+      secretKeyProvider: this.secretKeyProvider
     };
   }
   async insert(data) {
@@ -257,7 +308,7 @@ var Collection = class {
   }
   async findById(id) {
     const rows = await this.adapter.query(
-      `SELECT * FROM ${this.name} WHERE id = ? AND _deleted = 0`,
+      `SELECT * FROM ${quoteIdent2(this.name)} WHERE id = ? AND _deleted = 0`,
       [id]
     );
     const row = rows[0];
@@ -289,6 +340,9 @@ var Collection = class {
   }
 };
 
+// src/query/query-builder.ts
+import { quoteIdent as quoteIdent3 } from "@korajs/core";
+
 // src/query/pluralize.ts
 function isVowel(char) {
   if (!char) return false;
@@ -518,7 +572,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 ${quoteIdent3(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();
@@ -541,7 +595,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 ${quoteIdent3(relatedCollection)} WHERE ${quoteIdent3(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();
@@ -583,7 +637,7 @@ var QueryError2 = class extends Error {
 };
 
 // src/relations/relation-enforcer.ts
-import { KoraError, createOperation } from "@korajs/core";
+import { KoraError, createOperation, quoteIdent as quoteIdent4 } from "@korajs/core";
 
 // src/relations/relation-lookup.ts
 function buildRelationLookup(schema) {
@@ -686,7 +740,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 ${quoteIdent4(sourceCollection)} WHERE ${quoteIdent4(foreignKeyField)} = ? AND _deleted = 0`,
       [deletedRecordId]
     );
     if (referencingRows.length === 0) {
@@ -733,7 +787,7 @@ var RelationEnforcer = class {
       return [];
     }
     const referencingRows = await tx.query(
-      `SELECT id FROM ${sourceCollection} WHERE ${foreignKeyField} = ? AND _deleted = 0`,
+      `SELECT id FROM ${quoteIdent4(sourceCollection)} WHERE ${quoteIdent4(foreignKeyField)} = ? AND _deleted = 0`,
       [deletedRecordId]
     );
     if (referencingRows.length === 0) {
@@ -781,7 +835,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 ${quoteIdent4(sourceCollection)} WHERE ${quoteIdent4(foreignKeyField)} = ? AND _deleted = 0`,
       [deletedRecordId]
     );
     const count = countRows[0]?.cnt ?? 0;
@@ -1469,7 +1523,7 @@ var SubscriptionManager = class {
 };
 
 // src/sync/rebase-unsynced-operations.ts
-import { HybridLogicalClock as HybridLogicalClock2, MAX_LOGICAL } from "@korajs/core";
+import { HybridLogicalClock as HybridLogicalClock2, MAX_LOGICAL, quoteIdent as quoteIdent5 } from "@korajs/core";
 import { computeOperationId } from "@korajs/core/internal";
 var LOGICAL_COUNTER_LIMIT = MAX_LOGICAL + 1;
 function emptyResult() {
@@ -1483,7 +1537,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 ${quoteIdent5(`_kora_ops_${collectionName}`)}`
+    );
     for (const row of rows) {
       if (rebaseIds.has(row.id)) {
         rebased.push(deserializeOperationWithCollection(row, collectionName));
@@ -1552,7 +1608,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 ${quoteIdent5(opsTable)} WHERE id = ?`, [oldOp.id]);
       const opInsert = buildInsertQuery(
         opsTable,
         serializeOperation(newOp)
@@ -1561,11 +1617,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 ${quoteIdent5(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 ${quoteIdent5(oldOp.collection)} WHERE id = ?`,
         [oldOp.recordId]
       );
       const fieldVersions = parseFieldVersions(rows[0]?._field_versions);
@@ -1577,14 +1633,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 ${quoteIdent5(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 ${quoteIdent5(oldOp.collection)} SET _created_at = ? WHERE id = ? AND _created_at = ?`,
           [newOp.timestamp.wallTime, oldOp.recordId, oldOp.timestamp.wallTime]
         );
       }
@@ -1604,6 +1660,7 @@ import {
   createOperation as createOperation2,
   generateUUIDv7,
   isAtomicOp,
+  quoteIdent as quoteIdent6,
   resolveAtomicOp,
   toAtomicOp,
   validateRecord
@@ -1920,7 +1977,7 @@ var TransactionContext = class {
       }
     }
     const rows = await this.config.adapter.query(
-      `SELECT * FROM ${collectionName} WHERE id = ? AND _deleted = 0`,
+      `SELECT * FROM ${quoteIdent6(collectionName)} WHERE id = ? AND _deleted = 0`,
       [id]
     );
     let record = rows[0] ? deserializeRecord(rows[0], definition.fields) : null;
@@ -2020,6 +2077,7 @@ var Store = class {
   localMutationHandler;
   relationEnforcer = null;
   causalTracker = null;
+  secretKeyProvider;
   constructor(config) {
     this.schema = config.schema;
     this.adapter = config.adapter;
@@ -2028,6 +2086,7 @@ var Store = class {
     this.isolation = config.isolation ?? "shared";
     this.emitter = config.emitter ?? null;
     this.localMutationHandler = config.localMutationHandler ?? null;
+    this.secretKeyProvider = config.secretKeyProvider;
     this.subscriptionManager = new SubscriptionManager({
       onQuerySubscribed: config.onQuerySubscribed
     });
@@ -2070,7 +2129,8 @@ var Store = class {
         },
         this.relationEnforcer,
         this.localMutationHandler,
-        this.causalTracker
+        this.causalTracker,
+        this.secretKeyProvider
       );
       this.collections.set(name, col);
     }
@@ -2152,7 +2212,7 @@ var Store = class {
       return "skipped";
     }
     const existing = await this.adapter.query(
-      `SELECT id FROM _kora_ops_${collection} WHERE id = ?`,
+      `SELECT id FROM ${quoteIdent7(`_kora_ops_${collection}`)} WHERE id = ?`,
       [op.id]
     );
     if (existing.length > 0) {
@@ -2177,7 +2237,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 = ?`,
@@ -2199,7 +2260,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 = {
@@ -2257,7 +2318,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 ${quoteIdent7(collection)} WHERE id = ?`,
           [op.recordId]
         );
         const currentRow = currentRows[0];
@@ -2351,9 +2412,9 @@ 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 ${quoteIdent7(`_kora_ops_${collection}`)} WHERE record_id = ? AND type IN ('update', 'delete')`,
       [recordId]
     );
     if (orphanRows.length === 0) {
@@ -2366,7 +2427,7 @@ var Store = class {
       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 ${quoteIdent7(collection)} WHERE id = ?`,
           [recordId]
         );
         const current = rows[0];
@@ -2400,6 +2461,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) => HybridLogicalClock3.compare(a.timestamp, b.timestamp)
+      );
+      const folded = 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) => `${quoteIdent7(c)} = ?`).join(", ");
+          await tx.execute(`UPDATE ${quoteIdent7(collection)} SET ${setClause} WHERE id = ?`, [
+            ...cols.map((c) => serialized[c]),
+            recordId
+          ]);
+        }
+      }
+    }
   }
   /**
    * Get operations from a node within a sequence number range.
@@ -2416,7 +2508,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 ${quoteIdent7(`_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) {
@@ -2435,7 +2527,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 ${quoteIdent7(`_kora_ops_${collectionName}`)} ORDER BY sequence_number ASC`
       );
       for (const row of rows) {
         allOps.push(deserializeOperationWithCollection(row, collectionName));
@@ -2486,7 +2578,7 @@ var Store = class {
    */
   async exportAudit(options) {
     this.ensureOpen();
-    const { exportAudit: doExport } = await import("./export-audit-VPGQWNR6.js");
+    const { exportAudit: doExport } = await import("./export-audit-ODGQTQIK.js");
     return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
   }
   /**
@@ -2504,6 +2596,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).
    */
@@ -2531,7 +2639,8 @@ var Store = class {
       relationEnforcer: this.relationEnforcer,
       causalTracker: this.causalTracker,
       inTransaction: options?.inTransaction ?? false,
-      extraCausalDeps: options?.extraCausalDeps
+      extraCausalDeps: options?.extraCausalDeps,
+      secretKeyProvider: this.secretKeyProvider
     };
   }
   /**
@@ -2544,7 +2653,7 @@ var Store = class {
       return null;
     }
     const rows = await this.adapter.query(
-      `SELECT * FROM ${collection} WHERE id = ?`,
+      `SELECT * FROM ${quoteIdent7(collection)} WHERE id = ?`,
       [recordId]
     );
     const row = rows[0];
@@ -2569,7 +2678,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 ${quoteIdent7(collection)} WHERE id = ?`,
       [recordId]
     );
     const row = rows[0];
@@ -2612,6 +2721,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.
    */
@@ -2675,7 +2813,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 ${quoteIdent7(`_kora_ops_${collection}`)} WHERE node_id = ? AND record_id = ? ORDER BY sequence_number DESC LIMIT 1`,
       [this.nodeId, recordId]
     );
     const row = rows[0];
@@ -2690,7 +2828,7 @@ 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 ${quoteIdent7(`_kora_ops_${collection}`)} WHERE record_id = ?`,
       [recordId]
     );
     let latest = null;
@@ -2702,6 +2840,21 @@ var Store = class {
     }
     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 ${quoteIdent7(`_kora_ops_${collection}`)} WHERE record_id = ?`,
+      [recordId]
+    );
+    const ops = rows.map((row) => deserializeOperationWithCollection(row, collection));
+    ops.sort((a, b) => HybridLogicalClock3.compare(a.timestamp, b.timestamp));
+    return ops;
+  }
   /** Expose the subscription manager for direct access (e.g., by QueryBuilder) */
   getSubscriptionManager() {
     return this.subscriptionManager;
@@ -2780,7 +2933,7 @@ var Store = class {
    */
   async exportBackup(options) {
     this.ensureOpen();
-    const { exportBackup: doExport } = await import("./backup-5XZ7THNJ.js");
+    const { exportBackup: doExport } = await import("./backup-5S7K2Z35.js");
     return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
   }
   /**
@@ -2792,7 +2945,7 @@ var Store = class {
    */
   async importBackup(data, options) {
     this.ensureOpen();
-    const { restoreBackup: doRestore } = await import("./backup-5XZ7THNJ.js");
+    const { restoreBackup: doRestore } = await import("./backup-5S7K2Z35.js");
     return doRestore(this.adapter, this.schema, data, options);
   }
   /**
@@ -2877,14 +3030,14 @@ var Store = class {
    */
   async runBackfill(collection, transform) {
     const rows = await this.adapter.query(
-      `SELECT * FROM ${collection} WHERE _deleted = 0`
+      `SELECT * FROM ${quoteIdent7(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) => `${quoteIdent7(f)} = ?`).join(", ");
         const values = fields.map((f) => {
           const val = updates[f];
           if (typeof val === "boolean") return val ? 1 : 0;
@@ -2894,7 +3047,7 @@ var Store = class {
           return val;
         });
         values.push(row.id);
-        await tx.execute(`UPDATE ${collection} SET ${setClauses} WHERE id = ?`, values);
+        await tx.execute(`UPDATE ${quoteIdent7(collection)} SET ${setClauses} WHERE id = ?`, values);
       }
     });
   }
@@ -2954,6 +3107,7 @@ var QueryStore = class {
   listeners = /* @__PURE__ */ new Set();
   unsubscribeQuery = null;
   active = false;
+  hasEmittedSnapshot = false;
   queryBuilder;
   constructor(queryBuilder) {
     this.queryBuilder = queryBuilder;
@@ -2979,16 +3133,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();
     });
@@ -3422,12 +3585,519 @@ function asRichTextSyncEngine(engine) {
   }
   return engine;
 }
+
+// src/blob/opfs-blob-store.ts
+import { createBlobRef, hashBlob } from "@korajs/core";
+var OpfsBlobStore = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  shardFor(hash) {
+    return hash.slice(0, 2);
+  }
+  async put(bytes, metadata = {}) {
+    const ref = await createBlobRef(bytes, metadata);
+    const shard = this.shardFor(ref.hash);
+    if (await this.dir.has(shard, ref.hash)) {
+      return ref;
+    }
+    const out = new Uint8Array(bytes.byteLength);
+    out.set(bytes);
+    await this.dir.write(shard, ref.hash, out);
+    return ref;
+  }
+  async get(hash) {
+    const bytes = await this.dir.read(this.shardFor(hash), hash);
+    if (bytes === null) {
+      return null;
+    }
+    const actual = await hashBlob(bytes);
+    if (actual !== hash) {
+      throw new BlobIntegrityError(hash, actual);
+    }
+    return bytes;
+  }
+  async has(hash) {
+    return this.dir.has(this.shardFor(hash), hash);
+  }
+  async delete(hash) {
+    return this.dir.remove(this.shardFor(hash), hash);
+  }
+  async size() {
+    return this.dir.count();
+  }
+  async list() {
+    return this.dir.keys();
+  }
+};
+function getStorageManager() {
+  const nav = globalThis.navigator;
+  if (!nav?.storage || typeof nav.storage.getDirectory !== "function") {
+    throw new Error(
+      "OPFS is unavailable in this environment. The OPFS blob store requires a browser with Origin Private File System support; use MemoryBlobStore or a server-side store elsewhere."
+    );
+  }
+  return nav.storage;
+}
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && error.name === "NotFoundError";
+}
+async function createOpfsBlobDirectory(rootDirName = "kora-blobs") {
+  const storage = getStorageManager();
+  if (typeof storage.persist === "function") {
+    try {
+      await storage.persist();
+    } catch {
+    }
+  }
+  const opfsRoot = await storage.getDirectory();
+  const root = await opfsRoot.getDirectoryHandle(rootDirName, { create: true });
+  async function shardHandle(shard, create) {
+    try {
+      return await root.getDirectoryHandle(shard, { create });
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  return {
+    async read(shard, name) {
+      const dir = await shardHandle(shard, false);
+      if (!dir) {
+        return null;
+      }
+      let handle;
+      try {
+        handle = await dir.getFileHandle(name, { create: false });
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return null;
+        }
+        throw error;
+      }
+      const file = await handle.getFile();
+      return new Uint8Array(await file.arrayBuffer());
+    },
+    async write(shard, name, bytes) {
+      const dir = await root.getDirectoryHandle(shard, { create: true });
+      const handle = await dir.getFileHandle(name, { create: true });
+      const writable = await handle.createWritable({ keepExistingData: false });
+      try {
+        await writable.write(bytes);
+      } finally {
+        await writable.close();
+      }
+    },
+    async remove(shard, name) {
+      const dir = await shardHandle(shard, false);
+      if (!dir) {
+        return false;
+      }
+      try {
+        await dir.removeEntry(name);
+        return true;
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return false;
+        }
+        throw error;
+      }
+    },
+    async has(shard, name) {
+      const dir = await shardHandle(shard, false);
+      if (!dir) {
+        return false;
+      }
+      try {
+        await dir.getFileHandle(name, { create: false });
+        return true;
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return false;
+        }
+        throw error;
+      }
+    },
+    async count() {
+      let total = 0;
+      for await (const shard of root.keys()) {
+        const dir = await shardHandle(shard, false);
+        if (!dir) {
+          continue;
+        }
+        for await (const name of dir.keys()) {
+          if (!name.endsWith(".tmp")) {
+            total++;
+          }
+        }
+      }
+      return total;
+    },
+    async keys() {
+      const names = [];
+      for await (const shard of root.keys()) {
+        const dir = await shardHandle(shard, false);
+        if (!dir) {
+          continue;
+        }
+        for await (const name of dir.keys()) {
+          if (!name.endsWith(".tmp")) {
+            names.push(name);
+          }
+        }
+      }
+      return names;
+    }
+  };
+}
+async function createOpfsBlobStore(rootDirName = "kora-blobs") {
+  return new OpfsBlobStore(await createOpfsBlobDirectory(rootDirName));
+}
+
+// src/blob/blob-chunking.ts
+import { hashBlob as hashBlob2 } from "@korajs/core";
+var DEFAULT_CHUNK_SIZE = 256 * 1024;
+async function chunkBlob(bytes, chunkSize = DEFAULT_CHUNK_SIZE, metadata = {}) {
+  if (chunkSize <= 0) {
+    throw new Error(`chunkBlob requires a positive chunkSize, got ${chunkSize}`);
+  }
+  const chunkHashes = [];
+  const chunks = /* @__PURE__ */ new Map();
+  for (let offset = 0; offset < bytes.byteLength; offset += chunkSize) {
+    const end = Math.min(offset + chunkSize, bytes.byteLength);
+    const chunk = new Uint8Array(end - offset);
+    chunk.set(bytes.subarray(offset, end));
+    const hash = await hashBlob2(chunk);
+    chunkHashes.push(hash);
+    if (!chunks.has(hash)) {
+      chunks.set(hash, chunk);
+    }
+  }
+  const blobHash = await hashBlob2(bytes);
+  const manifest = {
+    blobHash,
+    size: bytes.byteLength,
+    chunkSize,
+    chunkHashes
+  };
+  if (metadata.mimeType !== void 0) {
+    manifest.mimeType = metadata.mimeType;
+  }
+  if (metadata.filename !== void 0) {
+    manifest.filename = metadata.filename;
+  }
+  return { manifest, chunks };
+}
+async function reassembleBlob(manifest, chunkStore) {
+  const parts = [];
+  let total = 0;
+  for (const hash of manifest.chunkHashes) {
+    const chunk = await chunkStore.get(hash);
+    if (chunk === null) {
+      throw new Error(`Cannot reassemble blob ${manifest.blobHash}: missing chunk ${hash}`);
+    }
+    parts.push(chunk);
+    total += chunk.byteLength;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.byteLength;
+  }
+  const actual = await hashBlob2(out);
+  if (actual !== manifest.blobHash) {
+    throw new BlobIntegrityError(manifest.blobHash, actual);
+  }
+  return out;
+}
+
+// src/blob/blob-transfer.ts
+import { hashBlob as hashBlob3 } from "@korajs/core";
+async function receiveBlob(manifest, provider, stores) {
+  let chunksFetched = 0;
+  let chunksSkipped = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const hash of manifest.chunkHashes) {
+    if (seen.has(hash)) {
+      continue;
+    }
+    seen.add(hash);
+    if (await stores.chunkStore.has(hash)) {
+      chunksSkipped++;
+      continue;
+    }
+    const bytes = await provider.getChunk(hash);
+    if (bytes === null) {
+      throw new Error(`Blob transfer failed: provider could not supply chunk ${hash}`);
+    }
+    const actual = await hashBlob3(bytes);
+    if (actual !== hash) {
+      throw new BlobIntegrityError(hash, actual);
+    }
+    await stores.chunkStore.put(bytes);
+    chunksFetched++;
+  }
+  const full = await reassembleBlob(manifest, stores.chunkStore);
+  const ref = await stores.blobStore.put(full, {
+    mimeType: manifest.mimeType,
+    filename: manifest.filename
+  });
+  return { ref, chunksFetched, chunksSkipped };
+}
+async function prepareBlobForSend(bytes, chunkStore, options = {}) {
+  const { manifest, chunks } = await chunkBlob(bytes, options.chunkSize, {
+    mimeType: options.mimeType,
+    filename: options.filename
+  });
+  for (const chunk of chunks.values()) {
+    await chunkStore.put(chunk);
+  }
+  const provider = {
+    getChunk: (hash) => chunkStore.get(hash)
+  };
+  return { manifest, provider };
+}
+
+// src/blob/blob-manifest-transfer.ts
+import { hashBlob as hashBlob4 } from "@korajs/core";
+function serializeBlobManifest(manifest) {
+  const canonical = {
+    blobHash: manifest.blobHash,
+    size: manifest.size,
+    chunkSize: manifest.chunkSize,
+    chunkHashes: manifest.chunkHashes
+  };
+  if (manifest.mimeType !== void 0) {
+    canonical.mimeType = manifest.mimeType;
+  }
+  if (manifest.filename !== void 0) {
+    canonical.filename = manifest.filename;
+  }
+  return new TextEncoder().encode(JSON.stringify(canonical));
+}
+function parseBlobManifest(bytes) {
+  const parsed = JSON.parse(new TextDecoder().decode(bytes));
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error("Invalid blob manifest: not an object");
+  }
+  const obj = parsed;
+  if (typeof obj.blobHash !== "string") {
+    throw new Error("Invalid blob manifest: missing blobHash");
+  }
+  if (typeof obj.size !== "number" || typeof obj.chunkSize !== "number") {
+    throw new Error("Invalid blob manifest: missing size or chunkSize");
+  }
+  if (!Array.isArray(obj.chunkHashes) || obj.chunkHashes.some((h) => typeof h !== "string")) {
+    throw new Error("Invalid blob manifest: chunkHashes must be an array of strings");
+  }
+  const manifest = {
+    blobHash: obj.blobHash,
+    size: obj.size,
+    chunkSize: obj.chunkSize,
+    chunkHashes: obj.chunkHashes
+  };
+  if (typeof obj.mimeType === "string") {
+    manifest.mimeType = obj.mimeType;
+  }
+  if (typeof obj.filename === "string") {
+    manifest.filename = obj.filename;
+  }
+  return manifest;
+}
+async function putBlobForTransfer(store, bytes, options = {}) {
+  const { manifest, chunks } = await chunkBlob(bytes, options.chunkSize, {
+    ...options.mimeType !== void 0 ? { mimeType: options.mimeType } : {},
+    ...options.filename !== void 0 ? { filename: options.filename } : {}
+  });
+  for (const chunk of chunks.values()) {
+    await store.put(chunk);
+  }
+  const baseRef = await store.put(bytes, {
+    ...options.mimeType !== void 0 ? { mimeType: options.mimeType } : {},
+    ...options.filename !== void 0 ? { filename: options.filename } : {}
+  });
+  const manifestRef = await store.put(serializeBlobManifest(manifest));
+  return { ref: { ...baseRef, manifestHash: manifestRef.hash }, manifest };
+}
+async function fetchBlobManifest(provider, manifestHash) {
+  const bytes = await provider.getChunk(manifestHash);
+  if (bytes === null) {
+    throw new Error(`Blob manifest ${manifestHash} could not be fetched from the provider`);
+  }
+  const actual = await hashBlob4(bytes);
+  if (actual !== manifestHash) {
+    throw new BlobIntegrityError(manifestHash, actual);
+  }
+  return parseBlobManifest(bytes);
+}
+async function resolveBlobManifest(provider, ref) {
+  if (ref.manifestHash === void 0) {
+    throw new Error(
+      `Blob ${ref.hash} has no manifest to resolve. Store it with putBlobForTransfer (or app.blobs.put) so its reference carries a manifestHash, or pull with an explicit manifest.`
+    );
+  }
+  return fetchBlobManifest(provider, ref.manifestHash);
+}
+
+// src/blob/server-blob-callbacks.ts
+import { hashBlob as hashBlob5 } from "@korajs/core";
+function toServerBlobCallbacks(store) {
+  return {
+    resolveBlobChunk: (hash) => store.get(hash),
+    async persistBlobChunk(hash, bytes) {
+      const actual = await hashBlob5(bytes);
+      if (actual !== hash) {
+        return;
+      }
+      await store.put(bytes);
+    }
+  };
+}
+function createMemoryServerBlobStore() {
+  const store = new MemoryBlobStore();
+  return { store, callbacks: toServerBlobCallbacks(store) };
+}
+
+// src/blob/blob-gc.ts
+import { isBlobRef } from "@korajs/core";
+function extractBlobRefs(record) {
+  const refs = [];
+  for (const value of Object.values(record)) {
+    if (isBlobRef(value)) {
+      refs.push(value);
+    }
+  }
+  return refs;
+}
+async function collectBlobGarbage(store, liveRefs, options = {}) {
+  const live = /* @__PURE__ */ new Set();
+  for (const ref of liveRefs) {
+    live.add(ref.hash);
+    if (ref.manifestHash === void 0) {
+      continue;
+    }
+    live.add(ref.manifestHash);
+    try {
+      const manifestBytes = await store.get(ref.manifestHash);
+      if (manifestBytes !== null) {
+        const manifest = parseBlobManifest(manifestBytes);
+        for (const chunkHash of manifest.chunkHashes) {
+          live.add(chunkHash);
+        }
+      }
+    } catch {
+    }
+  }
+  const all = await store.list();
+  const collectedHashes = [];
+  for (const hash of all) {
+    if (live.has(hash)) {
+      continue;
+    }
+    collectedHashes.push(hash);
+    if (!options.dryRun) {
+      await store.delete(hash);
+    }
+  }
+  return {
+    scanned: all.length,
+    live: live.size,
+    collected: collectedHashes.length,
+    collectedHashes
+  };
+}
+
+// src/blob/blob-chunk-transport.ts
+import { generateUUIDv7 as generateUUIDv74 } from "@korajs/core";
+function createRemoteChunkProvider(port, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const pending = /* @__PURE__ */ new Map();
+  port.onMessage((message) => {
+    if (message.type !== "blob-chunk-response") {
+      return;
+    }
+    const entry = pending.get(message.requestId);
+    if (!entry) {
+      return;
+    }
+    pending.delete(message.requestId);
+    clearTimeout(entry.timer);
+    entry.resolve(message.bytes);
+  });
+  return {
+    pendingCount: () => pending.size,
+    getChunk(hash) {
+      const requestId = generateUUIDv74();
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(requestId);
+          reject(new Error(`Blob chunk request for ${hash} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        pending.set(requestId, { resolve, reject, timer });
+        port.send({ type: "blob-chunk-request", requestId, hash });
+      });
+    }
+  };
+}
+function serveBlobChunks(port, blobStore) {
+  port.onMessage((message) => {
+    if (message.type !== "blob-chunk-request") {
+      return;
+    }
+    void blobStore.get(message.hash).then(
+      (bytes) => {
+        port.send({ type: "blob-chunk-response", requestId: message.requestId, bytes });
+      },
+      () => {
+        port.send({ type: "blob-chunk-response", requestId: message.requestId, bytes: null });
+      }
+    );
+  });
+}
+function createChunkPortPair() {
+  const handlersA = [];
+  const handlersB = [];
+  const a = {
+    send(message) {
+      queueMicrotask(() => {
+        for (const handler of handlersB) {
+          handler(message);
+        }
+      });
+    },
+    onMessage(handler) {
+      handlersA.push(handler);
+    }
+  };
+  const b = {
+    send(message) {
+      queueMicrotask(() => {
+        for (const handler of handlersA) {
+          handler(message);
+        }
+      });
+    },
+    onMessage(handler) {
+      handlersB.push(handler);
+    }
+  };
+  return { a, b };
+}
 export {
   AdapterError,
+  BlobIntegrityError,
   COMPACTION_BASELINE_META_KEY,
   Collection,
+  DEFAULT_CHUNK_SIZE,
   InvalidStateTransitionError,
   LAST_ACKED_SERVER_VECTOR_META_KEY,
+  MemoryBlobStore,
+  NoLeaderError,
+  OpfsBlobStore,
   OptimisticLockError,
   PersistenceError,
   QueryBuilder,
@@ -3445,26 +4115,44 @@ export {
   WorkerTimeoutError,
   asRichTextSyncEngine,
   assertQueryReady,
+  chunkBlob,
+  collectBlobGarbage,
   collectOperationsAheadOfServer,
   compactOperationLog,
   computeAckCompactionWatermark,
+  createChunkPortPair,
+  createMemoryServerBlobStore,
+  createOpfsBlobDirectory,
+  createOpfsBlobStore,
+  createRemoteChunkProvider,
   createRichTextController,
   decodeAuditExport,
   decodeRichtext,
   deserializeVersionVectorFromMeta,
   encodeRichtext,
   exportBackup,
+  extractBlobRefs,
+  fetchBlobManifest,
   getSharedQueryStoreCache,
   mergeVersionVectors,
+  parseBlobManifest,
   persistedAuditTraceFromEvent,
   pluralize,
+  prepareBlobForSend,
+  putBlobForTransfer,
   readAuditExportManifest,
   readBackupManifest,
+  reassembleBlob,
+  receiveBlob,
+  resolveBlobManifest,
   restoreBackup,
   richtextStatesEqual,
   richtextToPlainText,
+  serializeBlobManifest,
   serializeVersionVectorToMeta,
+  serveBlobChunks,
   singularize,
+  toServerBlobCallbacks,
   validateStateTransition,
   validateUpdateStateMachine,
   verifyAuditExportChecksum,