@korajs/store 1.0.0-beta.12 → 1.0.0-beta.14

package/dist/index.js

@@ -2,3168 +2,194 @@ import {
   decodeAuditExport,
   readAuditExportManifest,
   verifyAuditExportChecksum
-} from "./chunk-CYO3YKFL.js";
+} from "./chunk-5ZRRF6R2.js";
 import {
   persistedAuditTraceFromEvent
 } from "./chunk-MYSJN3DF.js";
 import {
-  BlobIntegrityError,
-  MemoryBlobStore
-} from "./chunk-W4MTTNEZ.js";
-import {
-  InvalidStateTransitionError,
-  allocateNextSequenceInTransaction,
-  allocateNextSequenceNumber,
-  buildCountQuery,
-  buildFieldFastForwardUpdateQuery,
-  buildInsertQuery,
-  buildLwwSoftDeleteQuery,
-  buildSelectQuery,
-  buildSoftDeleteQuery,
-  buildUpdateQuery,
-  executeDelete,
-  executeInsert,
-  executeUpdate,
-  fieldVersionsForFields,
-  isIncomingNewerThanRow,
-  parseFieldVersions,
-  readSequenceNumber,
-  resolvePerFieldLww,
-  serializeFieldVersions,
-  serializeRowVersion,
-  validateStateTransition,
-  validateUpdateStateMachine
-} from "./chunk-YT7MRFCP.js";
-import {
-  AdapterError,
-  NoLeaderError,
-  OptimisticLockError,
-  PersistenceError,
-  QueryError,
-  RecordNotFoundError,
-  StoreNotOpenError,
-  WorkerInitError,
-  WorkerTimeoutError
-} from "./chunk-TUR7RGEP.js";
-import {
-  exportBackup,
-  readBackupManifest,
-  restoreBackup,
-  verifyBackupChecksum
-} from "./chunk-HS6DBMST.js";
-import {
-  decodeRichtext,
-  decodeRichtextFieldsFromOpData,
-  deserializeOperationWithCollection,
-  deserializeRecord,
-  encodeRichtext,
-  encodeRichtextFieldsForOpData,
-  richtextStatesEqual,
-  richtextToPlainText,
-  serializeOperation,
-  serializeRecord
-} 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, quoteIdent } from "@korajs/core";
-function computeAckCompactionWatermark(serverVector) {
-  const watermark = createVersionVector();
-  for (const [nodeId, seq] of serverVector) {
-    if (seq > 0) {
-      watermark.set(nodeId, seq);
-    }
-  }
-  return watermark;
-}
-async function compactOperationLog(adapter, schema, strategy, serverVector) {
-  if (strategy.mode === "never") {
-    return { deletedCount: 0, watermark: createVersionVector() };
-  }
-  const watermark = computeAckCompactionWatermark(serverVector);
-  if (watermark.size === 0) {
-    return { deletedCount: 0, watermark };
-  }
-  const ageCutoffWall = strategy.mode === "after-days" ? Date.now() - strategy.days * 24 * 60 * 60 * 1e3 : null;
-  const ageCutoffSerialized = ageCutoffWall !== null ? HybridLogicalClock.serialize({
-    wallTime: ageCutoffWall,
-    logical: 0,
-    nodeId: ""
-  }).slice(0, 15) : null;
-  let deletedCount = 0;
-  const collectionNames = Object.keys(schema.collections);
-  await adapter.transaction(async (tx) => {
-    for (const collectionName of collectionNames) {
-      const table = quoteIdent(`_kora_ops_${collectionName}`);
-      for (const [nodeId, maxSeq] of watermark) {
-        if (maxSeq <= 0) continue;
-        const countSql = buildCountSql(table, ageCutoffSerialized !== null);
-        const countParams = ageCutoffSerialized !== null ? [nodeId, maxSeq, ageCutoffSerialized] : [nodeId, maxSeq];
-        const countRows = await tx.query(countSql, countParams);
-        deletedCount += countRows[0]?.count ?? 0;
-        const deleteSql = buildDeleteSql(table, ageCutoffSerialized !== null);
-        await tx.execute(deleteSql, countParams);
-      }
-    }
-    await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
-      COMPACTION_BASELINE_META_KEY,
-      String(Date.now())
-    ]);
-  });
-  return { deletedCount, watermark };
-}
-function buildCountSql(table, withAge) {
-  if (withAge) {
-    return `SELECT COUNT(*) as count FROM ${table} WHERE node_id = ? AND sequence_number <= ? AND SUBSTR(timestamp, 1, 15) < ?`;
-  }
-  return `SELECT COUNT(*) as count FROM ${table} WHERE node_id = ? AND sequence_number <= ?`;
-}
-function buildDeleteSql(table, withAge) {
-  if (withAge) {
-    return `DELETE FROM ${table} WHERE node_id = ? AND sequence_number <= ? AND SUBSTR(timestamp, 1, 15) < ?`;
-  }
-  return `DELETE FROM ${table} WHERE node_id = ? AND sequence_number <= ?`;
-}
-
-// src/sync/sync-state.ts
-import { createVersionVector as createVersionVector2 } from "@korajs/core";
-var LAST_ACKED_SERVER_VECTOR_META_KEY = "last_acked_server_vector";
-var DELTA_CURSOR_META_KEY = "delta_cursor";
-var DELIVERY_WATERMARK_META_KEY = "delivery_watermark";
-function serializeVersionVectorToMeta(vector) {
-  const record = {};
-  for (const [nodeId, seq] of vector) {
-    record[nodeId] = seq;
-  }
-  return JSON.stringify(record);
-}
-function deserializeVersionVectorFromMeta(value) {
-  const parsed = JSON.parse(value);
-  const vector = createVersionVector2();
-  for (const [nodeId, seq] of Object.entries(parsed)) {
-    if (typeof seq === "number" && seq >= 0) {
-      vector.set(nodeId, seq);
-    }
-  }
-  return vector;
-}
-function mergeVersionVectors(a, b) {
-  const merged = new Map(a);
-  for (const [nodeId, seq] of b) {
-    merged.set(nodeId, Math.max(merged.get(nodeId) ?? 0, seq));
-  }
-  return merged;
-}
-async function collectOperationsAheadOfServer(localVector, serverVector, fetchRange) {
-  const missing = [];
-  for (const [nodeId, localSeq] of localVector) {
-    const serverSeq = serverVector.get(nodeId) ?? 0;
-    if (localSeq > serverSeq) {
-      const ops = await fetchRange(nodeId, serverSeq + 1, localSeq);
-      missing.push(...ops);
-    }
-  }
-  missing.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
-  return missing;
-}
-async function loadLastAckedServerVector(adapter) {
-  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
-    LAST_ACKED_SERVER_VECTOR_META_KEY
-  ]);
-  const row = rows[0];
-  if (!row?.value) {
-    return createVersionVector2();
-  }
-  try {
-    return deserializeVersionVectorFromMeta(row.value);
-  } catch {
-    return createVersionVector2();
-  }
-}
-async function saveLastAckedServerVector(adapter, vector) {
-  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
-    LAST_ACKED_SERVER_VECTOR_META_KEY,
-    serializeVersionVectorToMeta(vector)
-  ]);
-}
-async function loadDeltaCursor(adapter) {
-  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
-    DELTA_CURSOR_META_KEY
-  ]);
-  return rows[0]?.value ?? null;
-}
-async function saveDeltaCursor(adapter, cursor) {
-  if (cursor === null) {
-    await adapter.execute("DELETE FROM _kora_meta WHERE key = ?", [DELTA_CURSOR_META_KEY]);
-    return;
-  }
-  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
-    DELTA_CURSOR_META_KEY,
-    cursor
-  ]);
-}
-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 {
-  CausalTracker,
-  HybridLogicalClock as HybridLogicalClock3,
-  createVersionVector as createVersionVector3,
-  generateUUIDv7 as generateUUIDv73,
-  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, secretKeyProvider) {
-    this.name = name;
-    this.definition = definition;
-    this.schema = schema;
-    this.adapter = adapter;
-    this.clock = clock;
-    this.nodeId = nodeId;
-    this.allocateSequenceNumber = allocateSequenceNumber;
-    this.onMutation = onMutation;
-    this.relationEnforcer = relationEnforcer;
-    this.mutationHandler = mutationHandler;
-    this.causalTracker = causalTracker;
-    this.secretKeyProvider = secretKeyProvider;
-  }
-  name;
-  definition;
-  schema;
-  adapter;
-  clock;
-  nodeId;
-  allocateSequenceNumber;
-  onMutation;
-  relationEnforcer;
-  mutationHandler;
-  causalTracker;
-  secretKeyProvider;
-  mutationContext() {
-    return {
-      collection: this.name,
-      definition: this.definition,
-      schema: this.schema,
-      adapter: this.adapter,
-      clock: this.clock,
-      nodeId: this.nodeId,
-      allocateSequenceNumber: this.allocateSequenceNumber,
-      onMutation: this.onMutation,
-      relationEnforcer: this.relationEnforcer,
-      causalTracker: this.causalTracker,
-      inTransaction: false,
-      secretKeyProvider: this.secretKeyProvider
-    };
-  }
-  async insert(data) {
-    if (this.mutationHandler) {
-      return this.mutationHandler.insert(this.name, data);
-    }
-    return executeInsert(this.mutationContext(), data);
-  }
-  async findById(id) {
-    const rows = await this.adapter.query(
-      `SELECT * FROM ${quoteIdent2(this.name)} WHERE id = ? AND _deleted = 0`,
-      [id]
-    );
-    const row = rows[0];
-    if (!row) return null;
-    return deserializeRecord(row, this.definition.fields);
-  }
-  async update(id, data) {
-    if (this.mutationHandler) {
-      return this.mutationHandler.update(this.name, id, data);
-    }
-    return executeUpdate(this.mutationContext(), id, data);
-  }
-  async delete(id) {
-    if (this.mutationHandler) {
-      await this.mutationHandler.delete(this.name, id);
-      return;
-    }
-    await executeDelete(this.mutationContext(), id);
-  }
-  getName() {
-    return this.name;
-  }
-  getDefinition() {
-    return this.definition;
-  }
-  /** Replace the mutation handler (e.g. after ApplyPipeline is wired in createApp). */
-  setMutationHandler(handler) {
-    this.mutationHandler = handler;
-  }
-};
-
-// src/query/query-builder.ts
-import { quoteIdent as quoteIdent3 } from "@korajs/core";
-
-// src/query/pluralize.ts
-function isVowel(char) {
-  if (!char) return false;
-  return "aeiouAEIOU".includes(char);
-}
-function pluralize(word) {
-  if (word.endsWith("s")) return word;
-  if (word.endsWith("y") && !isVowel(word[word.length - 2])) {
-    return `${word.slice(0, -1)}ies`;
-  }
-  if (word.endsWith("sh") || word.endsWith("ch") || word.endsWith("x") || word.endsWith("z")) {
-    return `${word}es`;
-  }
-  return `${word}s`;
-}
-function singularize(word) {
-  if (word.endsWith("ies") && !isVowel(word[word.length - 4])) {
-    return `${word.slice(0, -3)}y`;
-  }
-  if (word.endsWith("shes") || word.endsWith("ches") || word.endsWith("xes") || word.endsWith("zes")) {
-    return word.slice(0, -2);
-  }
-  if (word.endsWith("ses")) {
-    return word.slice(0, -2);
-  }
-  if (word.endsWith("s") && !word.endsWith("ss")) {
-    return word.slice(0, -1);
-  }
-  return word;
-}
-
-// src/query/query-builder.ts
-var QueryBuilder = class _QueryBuilder {
-  constructor(collectionName, definition, adapter, subscriptionManager, initialWhere = {}, schema) {
-    this.collectionName = collectionName;
-    this.definition = definition;
-    this.adapter = adapter;
-    this.subscriptionManager = subscriptionManager;
-    this.schema = schema;
-    this.descriptor = {
-      collection: collectionName,
-      where: { ...initialWhere },
-      orderBy: []
-    };
-  }
-  collectionName;
-  definition;
-  adapter;
-  subscriptionManager;
-  schema;
-  descriptor;
-  /**
-   * Add WHERE conditions (AND semantics, merged with existing conditions).
-   */
-  where(conditions) {
-    const clone = this.clone();
-    clone.descriptor = {
-      ...clone.descriptor,
-      where: { ...clone.descriptor.where, ...conditions }
-    };
-    return clone;
-  }
-  /**
-   * Add ORDER BY clause.
-   */
-  orderBy(field, direction = "asc") {
-    const clone = this.clone();
-    clone.descriptor = {
-      ...clone.descriptor,
-      orderBy: [...clone.descriptor.orderBy, { field, direction }]
-    };
-    return clone;
-  }
-  /**
-   * Set result limit.
-   */
-  limit(n) {
-    const clone = this.clone();
-    clone.descriptor = { ...clone.descriptor, limit: n };
-    return clone;
-  }
-  /**
-   * Set result offset.
-   */
-  offset(n) {
-    const clone = this.clone();
-    clone.descriptor = { ...clone.descriptor, offset: n };
-    return clone;
-  }
-  /**
-   * Include related records in the query results.
-   * Follows relations defined in the schema to batch-fetch related data.
-   *
-   * @param targets - Relation target names (collection names or relation names)
-   * @returns A new QueryBuilder with include targets added
-   *
-   * @example
-   * ```typescript
-   * const todosWithProject = await app.todos
-   *   .where({ completed: false })
-   *   .include('project')
-   *   .exec()
-   * ```
-   */
-  include(...targets) {
-    const clone = this.clone();
-    const existing = clone.descriptor.include ?? [];
-    clone.descriptor = {
-      ...clone.descriptor,
-      include: [...existing, ...targets]
-    };
-    return clone;
-  }
-  /**
-   * Execute the query and return results.
-   */
-  async exec() {
-    const { sql, params } = buildSelectQuery(this.descriptor, this.definition.fields);
-    const rows = await this.adapter.query(sql, params);
-    const records = rows.map((row) => deserializeRecord(row, this.definition.fields));
-    if (this.descriptor.include && this.descriptor.include.length > 0 && this.schema) {
-      await this.resolveIncludes(records);
-    }
-    return records;
-  }
-  /**
-   * Execute a COUNT query and return the count.
-   */
-  async count() {
-    const { sql, params } = buildCountQuery(this.descriptor, this.definition.fields);
-    const rows = await this.adapter.query(sql, params);
-    return rows[0]?.count ?? 0;
-  }
-  /**
-   * Subscribe to query results. Callback is called immediately with current results,
-   * then again whenever the results change due to mutations.
-   *
-   * @returns An unsubscribe function
-   */
-  subscribe(callback) {
-    const executeFn = () => this.exec();
-    const descriptorCopy = { ...this.descriptor };
-    if (descriptorCopy.include && descriptorCopy.include.length > 0 && this.schema) {
-      descriptorCopy.includeCollections = this.resolveIncludeCollections(descriptorCopy.include);
-    }
-    return this.subscriptionManager.registerAndFetch(
-      descriptorCopy,
-      callback,
-      executeFn
-    );
-  }
-  /** Get the internal descriptor (for testing/debugging) */
-  getDescriptor() {
-    return { ...this.descriptor };
-  }
-  clone() {
-    const qb = new _QueryBuilder(
-      this.collectionName,
-      this.definition,
-      this.adapter,
-      this.subscriptionManager,
-      {},
-      this.schema
-    );
-    qb.descriptor = {
-      ...this.descriptor,
-      where: { ...this.descriptor.where },
-      orderBy: [...this.descriptor.orderBy],
-      include: this.descriptor.include ? [...this.descriptor.include] : void 0,
-      includeCollections: this.descriptor.includeCollections ? [...this.descriptor.includeCollections] : void 0
-    };
-    return qb;
-  }
-  /**
-   * Resolve include targets to their actual collection names for subscription tracking.
-   */
-  resolveIncludeCollections(targets) {
-    if (!this.schema) return [];
-    const collections = [];
-    for (const target of targets) {
-      const relation = this.findRelation(target);
-      if (relation) {
-        if (relation.from === this.collectionName) {
-          collections.push(relation.to);
-        } else {
-          collections.push(relation.from);
-        }
-      }
-    }
-    return collections;
-  }
-  /**
-   * Resolve includes after primary query, batch-fetching related records.
-   */
-  async resolveIncludes(records) {
-    if (!this.schema || !this.descriptor.include || records.length === 0) return;
-    for (const target of this.descriptor.include) {
-      const relation = this.findRelation(target);
-      if (!relation) {
-        throw new QueryError2(
-          `No relation found for include target "${target}" on collection "${this.collectionName}". Check that a relation is defined in your schema that connects "${this.collectionName}" to "${target}".`
-        );
-      }
-      if (relation.from === this.collectionName) {
-        await this.resolveManyToOneInclude(records, relation, target);
-      } else {
-        await this.resolveOneToManyInclude(records, relation, target);
-      }
-    }
-  }
-  /**
-   * Many-to-one: collect FK values from primary results, batch-fetch related, attach as singular.
-   */
-  async resolveManyToOneInclude(records, relation, target) {
-    const fkField = relation.field;
-    const fkValues = records.map((r) => r[fkField]).filter((v) => v !== null && v !== void 0 && typeof v === "string");
-    if (fkValues.length === 0) {
-      const propName2 = singularize(target);
-      for (const record of records) {
-        ;
-        record[propName2] = null;
-      }
-      return;
-    }
-    const uniqueFks = [...new Set(fkValues)];
-    const relatedCollection = relation.to;
-    const relatedDef = this.schema?.collections[relatedCollection];
-    if (!relatedDef) return;
-    const placeholders = uniqueFks.map(() => "?").join(", ");
-    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();
-    for (const r of relatedRecords) {
-      lookup.set(r.id, r);
-    }
-    const propName = singularize(target);
-    for (const record of records) {
-      const fk = record[fkField];
-      record[propName] = fk ? lookup.get(fk) ?? null : null;
-    }
-  }
-  /**
-   * One-to-many: collect primary IDs, batch-fetch children, attach as array.
-   */
-  async resolveOneToManyInclude(records, relation, target) {
-    const primaryIds = records.map((r) => r.id);
-    const relatedCollection = relation.from;
-    const relatedDef = this.schema?.collections[relatedCollection];
-    if (!relatedDef) return;
-    const fkField = relation.field;
-    const placeholders = primaryIds.map(() => "?").join(", ");
-    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();
-    for (const r of relatedRecords) {
-      const fk = r[fkField];
-      if (!grouped.has(fk)) {
-        grouped.set(fk, []);
-      }
-      grouped.get(fk)?.push(r);
-    }
-    const propName = pluralize(target);
-    for (const record of records) {
-      ;
-      record[propName] = grouped.get(record.id) ?? [];
-    }
-  }
-  /**
-   * Find a relation definition matching the include target.
-   * Searches by relation name, target collection name, and singularized/pluralized variants.
-   */
-  findRelation(target) {
-    if (!this.schema) return null;
-    for (const [_name, rel] of Object.entries(this.schema.relations)) {
-      if (rel.from === this.collectionName && rel.to === target) return rel;
-      if (rel.to === this.collectionName && rel.from === target) return rel;
-      if (rel.from === this.collectionName && rel.to === pluralize(target)) return rel;
-      if (rel.to === this.collectionName && rel.from === pluralize(target)) return rel;
-      if (rel.from === this.collectionName && rel.to === singularize(target)) return rel;
-      if (rel.to === this.collectionName && rel.from === singularize(target)) return rel;
-    }
-    return null;
-  }
-};
-var QueryError2 = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "QueryError";
-  }
-};
-
-// src/relations/relation-enforcer.ts
-import { KoraError, createOperation, quoteIdent as quoteIdent4 } from "@korajs/core";
-
-// src/relations/relation-lookup.ts
-function buildRelationLookup(schema) {
-  const lookup = /* @__PURE__ */ new Map();
-  for (const [relationName, relation] of Object.entries(schema.relations)) {
-    const targetCollection = relation.to;
-    const existing = lookup.get(targetCollection) ?? [];
-    existing.push({
-      relationName,
-      sourceCollection: relation.from,
-      foreignKeyField: relation.field,
-      onDelete: relation.onDelete,
-      relation
-    });
-    lookup.set(targetCollection, existing);
-  }
-  return lookup;
-}
-function getIncomingRelations(lookup, collection) {
-  return lookup.get(collection) ?? [];
-}
-
-// src/relations/relation-enforcer.ts
-var ReferentialIntegrityError = class extends KoraError {
-  constructor(collection, recordId, referencingCollection, relationName, referencingCount) {
-    super(
-      `Cannot delete record "${recordId}" from "${collection}": ${referencingCount} record(s) in "${referencingCollection}" reference it via relation "${relationName}" with onDelete: 'restrict'. Delete or reassign the referencing records first.`,
-      "REFERENTIAL_INTEGRITY",
-      {
-        collection,
-        recordId,
-        referencingCollection,
-        relationName,
-        referencingCount
-      }
-    );
-    this.name = "ReferentialIntegrityError";
-  }
-};
-var RelationEnforcer = class {
-  lookup;
-  schema;
-  adapter;
-  clock;
-  nodeId;
-  constructor(config) {
-    this.schema = config.schema;
-    this.adapter = config.adapter;
-    this.clock = config.clock;
-    this.nodeId = config.nodeId;
-    this.lookup = buildRelationLookup(config.schema);
-  }
-  /**
-   * Enforce referential integrity after deleting a record.
-   *
-   * Must be called within a transaction. The transaction handle is used
-   * for all cascaded writes to ensure atomicity.
-   *
-   * @param collection - The collection the deleted record belongs to
-   * @param recordId - The ID of the deleted record
-   * @param tx - The active transaction handle
-   * @param causalDeps - Causal dependencies for generated operations
-   * @returns All additional operations created as side effects
-   * @throws {ReferentialIntegrityError} If a 'restrict' policy is violated
-   */
-  async enforceDelete(collection, recordId, tx, causalDeps) {
-    const incomingRelations = getIncomingRelations(this.lookup, collection);
-    if (incomingRelations.length === 0) {
-      return { operations: [] };
-    }
-    const allOperations = [];
-    const sortedRelations = [...incomingRelations].sort(
-      (a, b) => a.relationName.localeCompare(b.relationName)
-    );
-    for (const incoming of sortedRelations) {
-      const ops = await this.enforceRelation(incoming, recordId, tx, causalDeps);
-      allOperations.push(...ops);
-    }
-    return { operations: allOperations };
-  }
-  /**
-   * Enforce a single relation's onDelete policy.
-   */
-  async enforceRelation(incoming, deletedRecordId, tx, causalDeps) {
-    switch (incoming.onDelete) {
-      case "cascade":
-        return this.enforceCascade(incoming, deletedRecordId, tx, causalDeps);
-      case "set-null":
-        return this.enforceSetNull(incoming, deletedRecordId, tx, causalDeps);
-      case "restrict":
-        return this.enforceRestrict(incoming, deletedRecordId, tx);
-      case "no-action":
-        return [];
-    }
-  }
-  /**
-   * Cascade: delete all records in the source collection that reference
-   * the deleted record, then recursively cascade those deletes.
-   */
-  async enforceCascade(incoming, deletedRecordId, tx, causalDeps) {
-    const { sourceCollection, foreignKeyField } = incoming;
-    const referencingRows = await tx.query(
-      `SELECT id FROM ${quoteIdent4(sourceCollection)} WHERE ${quoteIdent4(foreignKeyField)} = ? AND _deleted = 0`,
-      [deletedRecordId]
-    );
-    if (referencingRows.length === 0) {
-      return [];
-    }
-    const operations = [];
-    for (const row of referencingRows) {
-      const now = Date.now();
-      const sequenceNumber = await allocateNextSequenceInTransaction(tx, this.nodeId);
-      const operation = await createOperation(
-        {
-          nodeId: this.nodeId,
-          type: "delete",
-          collection: sourceCollection,
-          recordId: row.id,
-          data: null,
-          previousData: null,
-          sequenceNumber,
-          causalDeps: [...causalDeps],
-          schemaVersion: this.schema.version
-        },
-        this.clock
-      );
-      const deleteQuery = buildSoftDeleteQuery(sourceCollection, row.id, now);
-      await tx.execute(deleteQuery.sql, deleteQuery.params);
-      const opInsert = buildInsertQuery(
-        `_kora_ops_${sourceCollection}`,
-        serializeOperation(operation)
-      );
-      await tx.execute(opInsert.sql, opInsert.params);
-      operations.push(operation);
-      const cascadeResult = await this.enforceDelete(sourceCollection, row.id, tx, [operation.id]);
-      operations.push(...cascadeResult.operations);
-    }
-    return operations;
-  }
-  /**
-   * Set-null: update all referencing records to set the foreign key to null.
-   */
-  async enforceSetNull(incoming, deletedRecordId, tx, causalDeps) {
-    const { sourceCollection, foreignKeyField } = incoming;
-    const collectionDef = this.schema.collections[sourceCollection];
-    if (!collectionDef) {
-      return [];
-    }
-    const referencingRows = await tx.query(
-      `SELECT id FROM ${quoteIdent4(sourceCollection)} WHERE ${quoteIdent4(foreignKeyField)} = ? AND _deleted = 0`,
-      [deletedRecordId]
-    );
-    if (referencingRows.length === 0) {
-      return [];
-    }
-    const operations = [];
-    for (const row of referencingRows) {
-      const now = Date.now();
-      const sequenceNumber = await allocateNextSequenceInTransaction(tx, this.nodeId);
-      const updateData = { [foreignKeyField]: null };
-      const previousData = { [foreignKeyField]: deletedRecordId };
-      const operation = await createOperation(
-        {
-          nodeId: this.nodeId,
-          type: "update",
-          collection: sourceCollection,
-          recordId: row.id,
-          data: { ...updateData },
-          previousData,
-          sequenceNumber,
-          causalDeps: [...causalDeps],
-          schemaVersion: this.schema.version
-        },
-        this.clock
-      );
-      const serializedChanges = serializeRecord(updateData, collectionDef.fields);
-      const updateQuery = buildUpdateQuery(sourceCollection, row.id, {
-        ...serializedChanges,
-        _updated_at: now
-      });
-      await tx.execute(updateQuery.sql, updateQuery.params);
-      const opRow = serializeOperation(operation);
-      const opInsert = buildInsertQuery(
-        `_kora_ops_${sourceCollection}`,
-        opRow
-      );
-      await tx.execute(opInsert.sql, opInsert.params);
-      operations.push(operation);
-    }
-    return operations;
-  }
-  /**
-   * Restrict: refuse the delete if any referencing records exist.
-   */
-  async enforceRestrict(incoming, deletedRecordId, tx) {
-    const { sourceCollection, foreignKeyField, relationName } = incoming;
-    const countRows = await tx.query(
-      `SELECT COUNT(*) as cnt FROM ${quoteIdent4(sourceCollection)} WHERE ${quoteIdent4(foreignKeyField)} = ? AND _deleted = 0`,
-      [deletedRecordId]
-    );
-    const count = countRows[0]?.cnt ?? 0;
-    if (count > 0) {
-      const targetCollection = incoming.relation.to;
-      throw new ReferentialIntegrityError(
-        targetCollection,
-        deletedRecordId,
-        sourceCollection,
-        relationName,
-        count
-      );
-    }
-    return [];
-  }
-  /**
-   * Get the relation lookup map for external use (e.g., by the merge engine).
-   */
-  getRelationLookup() {
-    return this.lookup;
-  }
-};
-
-// src/replay/replay-to.ts
-import { OperationError } from "@korajs/core";
-import { topologicalSort } from "@korajs/core/internal";
-function collectCausalClosure(allOps, targetOperationId) {
-  const opMap = /* @__PURE__ */ new Map();
-  for (const op of allOps) {
-    opMap.set(op.id, op);
-  }
-  const target = opMap.get(targetOperationId);
-  if (!target) {
-    throw new OperationError(
-      `Operation "${targetOperationId}" not found in the local operation log`,
-      {
-        operationId: targetOperationId
-      }
-    );
-  }
-  const included = /* @__PURE__ */ new Set();
-  const stack = [targetOperationId];
-  while (stack.length > 0) {
-    const id = stack.pop();
-    if (id === void 0 || included.has(id)) {
-      continue;
-    }
-    included.add(id);
-    const op = opMap.get(id);
-    if (!op) {
-      continue;
-    }
-    for (const depId of op.causalDeps) {
-      if (opMap.has(depId)) {
-        stack.push(depId);
-      }
-    }
-  }
-  const subset = allOps.filter((op) => included.has(op.id));
-  return topologicalSort(subset);
-}
-function buildReplaySnapshot(schema, allOps, targetOperationId) {
-  const operationsApplied = collectCausalClosure(allOps, targetOperationId);
-  const targetOperation = operationsApplied.find((op) => op.id === targetOperationId);
-  if (!targetOperation) {
-    throw new OperationError(`Operation "${targetOperationId}" not found after causal sort`, {
-      operationId: targetOperationId
-    });
-  }
-  const memory = /* @__PURE__ */ new Map();
-  for (const op of operationsApplied) {
-    applyOperationToMemory(memory, op, schema);
-  }
-  const collections = materializeCollections(schema, memory);
-  return {
-    targetOperation,
-    operationsApplied,
-    collections,
-    findRecord(collection, recordId) {
-      const colMap = memory.get(collection);
-      const record = colMap?.get(recordId);
-      if (!record || record.deleted) {
-        return null;
-      }
-      const definition = schema.collections[collection];
-      if (!definition) {
-        return null;
-      }
-      return toCollectionRecord(record, definition);
-    }
-  };
-}
-function applyOperationToMemory(state, op, schema) {
-  const definition = schema.collections[op.collection];
-  if (!definition) {
-    return;
-  }
-  let colMap = state.get(op.collection);
-  if (!colMap) {
-    colMap = /* @__PURE__ */ new Map();
-    state.set(op.collection, colMap);
-  }
-  const wallTime = op.timestamp.wallTime;
-  switch (op.type) {
-    case "insert": {
-      if (!op.data) {
-        return;
-      }
-      colMap.set(op.recordId, {
-        id: op.recordId,
-        // op.data stores binary richtext as tagged JSON; snapshots must
-        // expose record-shaped values (Uint8Array/string).
-        fields: decodeRichtextFieldsFromOpData(op.data, definition.fields),
-        deleted: false,
-        createdAt: wallTime,
-        updatedAt: wallTime
-      });
-      break;
-    }
-    case "update": {
-      if (!op.data) {
-        return;
-      }
-      const decodedData = decodeRichtextFieldsFromOpData(op.data, definition.fields);
-      const existing = colMap.get(op.recordId);
-      if (existing && !existing.deleted) {
-        existing.fields = { ...existing.fields, ...decodedData };
-        existing.updatedAt = wallTime;
-        break;
-      }
-      if (existing?.deleted) {
-        return;
-      }
-      colMap.set(op.recordId, {
-        id: op.recordId,
-        fields: decodedData,
-        deleted: false,
-        createdAt: wallTime,
-        updatedAt: wallTime
-      });
-      break;
-    }
-    case "delete": {
-      const existing = colMap.get(op.recordId);
-      if (existing) {
-        existing.deleted = true;
-        existing.updatedAt = wallTime;
-        return;
-      }
-      colMap.set(op.recordId, {
-        id: op.recordId,
-        fields: {},
-        deleted: true,
-        createdAt: wallTime,
-        updatedAt: wallTime
-      });
-      break;
-    }
-  }
-}
-function materializeCollections(schema, memory) {
-  const collections = {};
-  for (const [collectionName, definition] of Object.entries(schema.collections)) {
-    const colMap = memory.get(collectionName);
-    const records = [];
-    if (colMap) {
-      for (const record of colMap.values()) {
-        if (!record.deleted) {
-          records.push(toCollectionRecord(record, definition));
-        }
-      }
-    }
-    collections[collectionName] = records;
-  }
-  return collections;
-}
-function toCollectionRecord(record, definition) {
-  const result = {
-    id: record.id,
-    createdAt: record.createdAt,
-    updatedAt: record.updatedAt
-  };
-  for (const [fieldName] of Object.entries(definition.fields)) {
-    if (fieldName in record.fields) {
-      result[fieldName] = record.fields[fieldName];
-    }
-  }
-  return result;
-}
-
-// src/sequences/sequence-manager.ts
-import { defaultSequenceFormat, formatSequenceValue } from "@korajs/core";
-var SequenceManager = class {
-  adapter;
-  nodeId;
-  constructor(adapter, nodeId) {
-    this.adapter = adapter;
-    this.nodeId = nodeId;
-  }
-  /**
-   * Get the next value in a sequence, atomically incrementing the counter.
-   *
-   * @param name - The sequence name (e.g., 'receipt', 'invoice')
-   * @param config - Optional configuration for scope, format, and starting value
-   * @returns The formatted sequence value
-   */
-  async next(name, config) {
-    const scope = config?.scope ?? "";
-    const startAt = config?.startAt ?? 1;
-    const format = config?.format ?? defaultSequenceFormat(name);
-    let counter = 0;
-    await this.adapter.transaction(async (tx) => {
-      const rows = await tx.query(
-        "SELECT counter FROM _kora_sequences WHERE name = ? AND scope = ? AND node_id = ?",
-        [name, scope, this.nodeId]
-      );
-      if (rows.length > 0) {
-        const row = rows[0];
-        counter = row.counter + 1;
-        await tx.execute(
-          "UPDATE _kora_sequences SET counter = ? WHERE name = ? AND scope = ? AND node_id = ?",
-          [counter, name, scope, this.nodeId]
-        );
-      } else {
-        counter = startAt;
-        await tx.execute(
-          "INSERT INTO _kora_sequences (name, scope, node_id, counter) VALUES (?, ?, ?, ?)",
-          [name, scope, this.nodeId, counter]
-        );
-      }
-    });
-    return formatSequenceValue(format, counter, this.nodeId);
-  }
-  /**
-   * Get the current counter value without incrementing.
-   *
-   * @param name - The sequence name
-   * @param config - Optional scope
-   * @returns The current counter value, or 0 if the sequence has never been used
-   */
-  async current(name, config) {
-    const scope = config?.scope ?? "";
-    const rows = await this.adapter.query(
-      "SELECT counter FROM _kora_sequences WHERE name = ? AND scope = ? AND node_id = ?",
-      [name, scope, this.nodeId]
-    );
-    if (rows.length > 0) {
-      return rows[0].counter;
-    }
-    return 0;
-  }
-  /**
-   * Reset a sequence counter.
-   *
-   * @param name - The sequence name
-   * @param config - Optional scope and target value
-   */
-  async reset(name, config) {
-    const scope = config?.scope ?? "";
-    const to = config?.to ?? 0;
-    await this.adapter.execute(
-      "DELETE FROM _kora_sequences WHERE name = ? AND scope = ? AND node_id = ?",
-      [name, scope, this.nodeId]
-    );
-    if (to > 0) {
-      await this.adapter.execute(
-        "INSERT INTO _kora_sequences (name, scope, node_id, counter) VALUES (?, ?, ?, ?)",
-        [name, scope, this.nodeId, to]
-      );
-    }
-  }
-};
-
-// src/subscription/bloom-filter.ts
-var FNV_OFFSET_BASIS = 2166136261;
-var FNV_PRIME = 16777619;
-function fnv1a32(input) {
-  let hash = FNV_OFFSET_BASIS;
-  for (let i = 0; i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, FNV_PRIME);
-  }
-  return hash >>> 0;
-}
-function optimalBitCount(expectedItems, falsePositiveRate) {
-  if (expectedItems <= 0) return 32;
-  if (falsePositiveRate <= 0 || falsePositiveRate >= 1) return 32;
-  const ln2Squared = Math.LN2 * Math.LN2;
-  const rawBits = -(expectedItems * Math.log(falsePositiveRate)) / ln2Squared;
-  const aligned = Math.ceil(rawBits / 32) * 32;
-  return Math.max(32, aligned);
-}
-function optimalHashCount(bitCount, expectedItems) {
-  if (expectedItems <= 0) return 1;
-  const raw = bitCount / expectedItems * Math.LN2;
-  return Math.max(1, Math.min(30, Math.round(raw)));
-}
-var SubscriptionBloomFilter = class {
-  bits;
-  bitCount;
-  hashCount;
-  itemCount = 0;
-  constructor(expectedItems, falsePositiveRate = 0.01) {
-    this.bitCount = optimalBitCount(expectedItems, falsePositiveRate);
-    this.hashCount = optimalHashCount(this.bitCount, expectedItems);
-    this.bits = new Uint32Array(this.bitCount / 32);
-  }
-  /**
-   * Add a collection (and optional field) to the bloom filter.
-   *
-   * @param collection - Collection name (e.g., "todos")
-   * @param field - Optional field name (e.g., "completed")
-   */
-  add(collection, field) {
-    const key = field !== void 0 ? `${collection}:${field}` : collection;
-    const positions = this.getPositions(key);
-    for (const pos of positions) {
-      const wordIndex = pos >>> 5;
-      const bitIndex = pos & 31;
-      const current = this.bits[wordIndex] ?? 0;
-      this.bits[wordIndex] = current | 1 << bitIndex;
-    }
-    this.itemCount++;
-  }
-  /**
-   * Check if a collection (and optional field) might be in the filter.
-   *
-   * A return value of `false` means the item is DEFINITELY NOT in the filter.
-   * A return value of `true` means the item MIGHT be in the filter (possible false positive).
-   *
-   * @param collection - Collection name to check
-   * @param field - Optional field name to check
-   * @returns false = definitely absent, true = possibly present
-   */
-  mightContain(collection, field) {
-    const key = field !== void 0 ? `${collection}:${field}` : collection;
-    const positions = this.getPositions(key);
-    for (const pos of positions) {
-      const wordIndex = pos >>> 5;
-      const bitIndex = pos & 31;
-      if (((this.bits[wordIndex] ?? 0) & 1 << bitIndex) === 0) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Reset the bloom filter, clearing all bits and the item count.
-   */
-  clear() {
-    this.bits.fill(0);
-    this.itemCount = 0;
-  }
-  /**
-   * Estimate the current false positive rate based on the number of items inserted.
-   *
-   * Formula: (1 - e^(-kn/m))^k
-   * where k = hash count, n = item count, m = bit count.
-   *
-   * @returns Estimated false positive rate as a number between 0 and 1
-   */
-  estimatedFalsePositiveRate() {
-    if (this.itemCount === 0) return 0;
-    const exponent = -(this.hashCount * this.itemCount) / this.bitCount;
-    return (1 - Math.exp(exponent)) ** this.hashCount;
-  }
-  /**
-   * @returns The number of items that have been added to the filter
-   */
-  getItemCount() {
-    return this.itemCount;
-  }
-  /**
-   * @returns The total number of bits in the filter
-   */
-  getBitCount() {
-    return this.bitCount;
-  }
-  /**
-   * @returns The number of hash functions used
-   */
-  getHashCount() {
-    return this.hashCount;
-  }
-  /**
-   * Count the number of bits currently set to 1.
-   * Uses Brian Kernighan's algorithm: each iteration clears the lowest set bit,
-   * so the loop runs exactly as many times as there are set bits.
-   *
-   * @returns Number of bits set to 1
-   */
-  getSetBitCount() {
-    let count = 0;
-    for (let i = 0; i < this.bits.length; i++) {
-      let word = this.bits[i] ?? 0;
-      while (word !== 0) {
-        word &= word - 1;
-        count++;
-      }
-    }
-    return count;
-  }
-  /**
-   * Compute k bit positions for a given key using Kirsch-Mitzenmacker double hashing.
-   *
-   * Instead of computing k independent hash functions, we compute two base hashes
-   * (h1 and h2) and derive the rest as: h_i = (h1 + i * h2) mod m.
-   * This technique is proven to have the same asymptotic false positive rate as
-   * k independent hash functions.
-   *
-   * We derive h1 and h2 from a single FNV-1a hash by splitting and mixing:
-   * h1 = fnv1a(key), h2 = fnv1a(key + "\0salt") to ensure independence.
-   */
-  getPositions(key) {
-    const h1 = fnv1a32(key);
-    const h2 = fnv1a32(`${key}\0bloom`);
-    const positions = new Array(this.hashCount);
-    for (let i = 0; i < this.hashCount; i++) {
-      positions[i] = (h1 + Math.imul(i, h2) >>> 0) % this.bitCount;
-    }
-    return positions;
-  }
-};
-
-// src/subscription/subscription-manager.ts
-var nextSubId = 0;
-var DEFAULT_BLOOM_THRESHOLD = 100;
-var DEFAULT_BLOOM_EXPECTED_ITEMS = 500;
-var DEFAULT_BLOOM_FALSE_POSITIVE_RATE = 0.01;
-var SubscriptionManager = class {
-  subscriptions = /* @__PURE__ */ new Map();
-  pendingCollections = /* @__PURE__ */ new Set();
-  flushScheduled = false;
-  onQuerySubscribed;
-  // Bloom filter state
-  bloomFilter = null;
-  bloomDirty = false;
-  bloomThreshold;
-  bloomExpectedItems;
-  bloomFalsePositiveRate;
-  // Performance stats
-  totalChecks = 0;
-  bloomFilterHits = 0;
-  bloomFilterMisses = 0;
-  falsePositives = 0;
-  totalCheckTimeMs = 0;
-  constructor(options) {
-    this.bloomThreshold = options?.bloomThreshold ?? DEFAULT_BLOOM_THRESHOLD;
-    this.bloomExpectedItems = options?.bloomExpectedItems ?? DEFAULT_BLOOM_EXPECTED_ITEMS;
-    this.bloomFalsePositiveRate = options?.bloomFalsePositiveRate ?? DEFAULT_BLOOM_FALSE_POSITIVE_RATE;
-    this.onQuerySubscribed = options?.onQuerySubscribed;
-  }
-  /**
-   * Register a new subscription.
-   *
-   * @param descriptor - The query descriptor defining what this subscription watches
-   * @param callback - Called with results whenever they change
-   * @param executeFn - Function to re-execute the query and get current results
-   * @returns An unsubscribe function
-   */
-  register(descriptor, callback, executeFn) {
-    const id = `sub_${++nextSubId}`;
-    const subscription = {
-      id,
-      descriptor,
-      callback,
-      executeFn,
-      lastResults: []
-    };
-    this.subscriptions.set(id, subscription);
-    this.bloomDirty = true;
-    const externalCleanup = this.onQuerySubscribed?.(descriptor);
-    return () => {
-      this.subscriptions.delete(id);
-      this.bloomDirty = true;
-      externalCleanup?.();
-    };
-  }
-  /**
-   * Register a subscription and immediately execute the query.
-   * The initial results are stored as lastResults so subsequent flushes
-   * correctly diff against the initial state.
-   *
-   * @returns An unsubscribe function
-   */
-  registerAndFetch(descriptor, callback, executeFn) {
-    const id = `sub_${++nextSubId}`;
-    const subscription = {
-      id,
-      descriptor,
-      callback,
-      executeFn,
-      lastResults: []
-    };
-    this.subscriptions.set(id, subscription);
-    this.bloomDirty = true;
-    const externalCleanup = this.onQuerySubscribed?.(descriptor);
-    executeFn().then((results) => {
-      if (this.subscriptions.has(id)) {
-        subscription.lastResults = results;
-        callback(results);
-      }
-    });
-    return () => {
-      this.subscriptions.delete(id);
-      this.bloomDirty = true;
-      externalCleanup?.();
-    };
-  }
-  /**
-   * Notify the manager that a mutation occurred on a collection.
-   * Schedules a microtask flush to batch multiple mutations in the same tick.
-   */
-  notify(collection, _operation) {
-    this.invalidate(collection);
-  }
-  /** Invalidate a collection after a local-view change that has no domain operation. */
-  invalidate(collection) {
-    this.pendingCollections.add(collection);
-    this.scheduleFlush();
-  }
-  /**
-   * Immediately flush all pending notifications.
-   * Useful for testing. In production, flushing happens via microtask.
-   */
-  async flush() {
-    if (this.pendingCollections.size === 0) return;
-    const collections = new Set(this.pendingCollections);
-    this.pendingCollections.clear();
-    this.flushScheduled = false;
-    const affected = this.findAffectedSubscriptions(collections);
-    for (const sub of affected) {
-      try {
-        const newResults = await sub.executeFn();
-        if (!this.resultsEqual(sub.lastResults, newResults)) {
-          sub.lastResults = newResults;
-          sub.callback(newResults);
-        }
-      } catch {
-      }
-    }
-  }
-  /**
-   * Remove all subscriptions. Called on store close.
-   */
-  clear() {
-    this.subscriptions.clear();
-    this.pendingCollections.clear();
-    this.flushScheduled = false;
-    this.bloomFilter = null;
-    this.bloomDirty = false;
-    this.totalChecks = 0;
-    this.bloomFilterHits = 0;
-    this.bloomFilterMisses = 0;
-    this.falsePositives = 0;
-    this.totalCheckTimeMs = 0;
-  }
-  /** Number of active subscriptions (for testing/debugging) */
-  get size() {
-    return this.subscriptions.size;
-  }
-  /**
-   * Get performance statistics for monitoring subscription checking efficiency.
-   * Useful for DevTools integration and performance tuning.
-   */
-  getStats() {
-    return {
-      totalChecks: this.totalChecks,
-      bloomFilterHits: this.bloomFilterHits,
-      bloomFilterMisses: this.bloomFilterMisses,
-      falsePositives: this.falsePositives,
-      averageCheckTimeMs: this.totalChecks > 0 ? this.totalCheckTimeMs / this.totalChecks : 0,
-      bloomFilterActive: this.isBloomActive(),
-      subscriptionCount: this.subscriptions.size
-    };
-  }
-  /**
-   * Check if bloom filter is currently active.
-   * Active when subscription count meets or exceeds the threshold.
-   */
-  isBloomActive() {
-    return this.subscriptions.size >= this.bloomThreshold;
-  }
-  /**
-   * Find subscriptions affected by mutations to the given collections.
-   * Uses two-level checking when bloom filter is active:
-   *
-   * Level 1: Bloom filter pre-check -- if no subscription depends on any
-   * of the mutated collections, skip everything (O(k) per collection).
-   *
-   * Level 2: Precise check -- linear scan of subscriptions, matching
-   * against the mutated collections.
-   */
-  findAffectedSubscriptions(collections) {
-    const startTime = performance.now();
-    this.totalChecks++;
-    const useBloom = this.isBloomActive();
-    if (useBloom) {
-      if (this.bloomDirty || this.bloomFilter === null) {
-        this.rebuildBloomFilter();
-      }
-      const filter = this.bloomFilter;
-      if (filter !== null) {
-        let anyPossibleMatch = false;
-        for (const col of collections) {
-          if (filter.mightContain(col)) {
-            anyPossibleMatch = true;
-            break;
-          }
-        }
-        if (!anyPossibleMatch) {
-          this.bloomFilterMisses++;
-          this.totalCheckTimeMs += performance.now() - startTime;
-          return [];
-        }
-        this.bloomFilterHits++;
-      }
-    }
-    const affected = [];
-    let anyPreciseMatch = false;
-    for (const sub of this.subscriptions.values()) {
-      if (collections.has(sub.descriptor.collection)) {
-        affected.push(sub);
-        anyPreciseMatch = true;
-      } else if (sub.descriptor.includeCollections) {
-        for (const incCol of sub.descriptor.includeCollections) {
-          if (collections.has(incCol)) {
-            affected.push(sub);
-            anyPreciseMatch = true;
-            break;
-          }
-        }
-      }
-    }
-    if (useBloom && !anyPreciseMatch) {
-      this.falsePositives++;
-    }
-    this.totalCheckTimeMs += performance.now() - startTime;
-    return affected;
-  }
-  /**
-   * Rebuild the bloom filter from all current subscriptions.
-   * Adds collection-level dependencies for every subscription, plus
-   * any included collection dependencies.
-   */
-  rebuildBloomFilter() {
-    const filter = new SubscriptionBloomFilter(this.bloomExpectedItems, this.bloomFalsePositiveRate);
-    for (const sub of this.subscriptions.values()) {
-      filter.add(sub.descriptor.collection);
-      if (sub.descriptor.includeCollections) {
-        for (const incCol of sub.descriptor.includeCollections) {
-          filter.add(incCol);
-        }
-      }
-    }
-    this.bloomFilter = filter;
-    this.bloomDirty = false;
-  }
-  scheduleFlush() {
-    if (this.flushScheduled) return;
-    this.flushScheduled = true;
-    queueMicrotask(() => {
-      this.flush();
-    });
-  }
-  /**
-   * Compare two result sets. Uses ID-based comparison first (same length, same IDs),
-   * then deep comparison of remaining fields when IDs match.
-   * Avoids JSON.stringify which is O(n) and fragile to field ordering differences.
-   */
-  resultsEqual(prev, next) {
-    if (prev.length !== next.length) return false;
-    if (prev.length === 0) return true;
-    for (let i = 0; i < prev.length; i++) {
-      if (prev[i]?.id !== next[i]?.id) return false;
-    }
-    for (let i = 0; i < prev.length; i++) {
-      const a = prev[i];
-      const b = next[i];
-      const keysA = Object.keys(a);
-      const keysB = Object.keys(b);
-      if (keysA.length !== keysB.length) return false;
-      for (const key of keysA) {
-        if (a[key] !== b[key]) return false;
-      }
-    }
-    return true;
-  }
-};
-
-// src/sync/rebase-unsynced-operations.ts
-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() {
-  return { operations: [], idMapping: {}, rebasedCount: 0, newMaxTimestamp: null };
-}
-async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, correctedNowMs) {
-  if (unsyncedOpIds.length === 0) {
-    return emptyResult();
-  }
-  const rebaseIds = new Set(unsyncedOpIds);
-  const rebased = [];
-  let maxOtherSerializedTs = null;
-  for (const collectionName of Object.keys(schema.collections)) {
-    const rows = await adapter.query(
-      `SELECT * FROM ${quoteIdent5(`_kora_ops_${collectionName}`)}`
-    );
-    for (const row of rows) {
-      if (rebaseIds.has(row.id)) {
-        rebased.push(deserializeOperationWithCollection(row, collectionName));
-      } else if (maxOtherSerializedTs === null || row.timestamp > maxOtherSerializedTs) {
-        maxOtherSerializedTs = row.timestamp;
-      }
-    }
-  }
-  if (rebased.length === 0) {
-    return emptyResult();
-  }
-  const maxOtherWallTime = maxOtherSerializedTs === null ? Number.NEGATIVE_INFINITY : HybridLogicalClock2.deserialize(maxOtherSerializedTs).wallTime;
-  const baseWallTime = Math.max(correctedNowMs, maxOtherWallTime + 1);
-  rebased.sort((a, b) => HybridLogicalClock2.compare(a.timestamp, b.timestamp));
-  const newTimestamps = rebased.map((op, i) => ({
-    // Spill into wallTime past the 5-digit logical serialization limit so the
-    // serialized order stays correct even for enormous offline queues.
-    wallTime: baseWallTime + Math.floor(i / LOGICAL_COUNTER_LIMIT),
-    logical: i % LOGICAL_COUNTER_LIMIT,
-    nodeId: op.nodeId
-  }));
-  const idMapping = {};
-  const newIds = [];
-  for (let i = 0; i < rebased.length; i++) {
-    const op = rebased[i];
-    const ts = newTimestamps[i];
-    if (!op || !ts) {
-      continue;
-    }
-    const input = {
-      nodeId: op.nodeId,
-      type: op.type,
-      collection: op.collection,
-      recordId: op.recordId,
-      data: op.data,
-      previousData: op.previousData,
-      sequenceNumber: op.sequenceNumber,
-      causalDeps: op.causalDeps,
-      schemaVersion: op.schemaVersion,
-      ...op.atomicOps !== void 0 ? { atomicOps: op.atomicOps } : {}
-    };
-    const newId = await computeOperationId(input, HybridLogicalClock2.serialize(ts));
-    idMapping[op.id] = newId;
-    newIds.push(newId);
-  }
-  const newOperations = [];
-  for (let i = 0; i < rebased.length; i++) {
-    const op = rebased[i];
-    const ts = newTimestamps[i];
-    const newId = newIds[i];
-    if (!op || !ts || newId === void 0) {
-      continue;
-    }
-    newOperations.push({
-      ...op,
-      id: newId,
-      timestamp: ts,
-      causalDeps: op.causalDeps.map((dep) => idMapping[dep] ?? dep)
-    });
-  }
-  await adapter.transaction(async (tx) => {
-    for (let i = 0; i < rebased.length; i++) {
-      const oldOp = rebased[i];
-      const newOp = newOperations[i];
-      if (!oldOp || !newOp) {
-        continue;
-      }
-      const opsTable = `_kora_ops_${oldOp.collection}`;
-      await tx.execute(`DELETE FROM ${quoteIdent5(opsTable)} WHERE id = ?`, [oldOp.id]);
-      const opInsert = buildInsertQuery(
-        opsTable,
-        serializeOperation(newOp)
-      );
-      await tx.execute(opInsert.sql, opInsert.params);
-      const oldVersion = serializeRowVersion(oldOp.timestamp);
-      const newVersion = serializeRowVersion(newOp.timestamp);
-      await tx.execute(
-        `UPDATE ${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 ${quoteIdent5(oldOp.collection)} WHERE id = ?`,
-        [oldOp.recordId]
-      );
-      const fieldVersions = parseFieldVersions(rows[0]?._field_versions);
-      let changed = false;
-      for (const [field, version] of Object.entries(fieldVersions)) {
-        if (version === oldVersion) {
-          fieldVersions[field] = newVersion;
-          changed = true;
-        }
-      }
-      if (changed) {
-        await tx.execute(
-          `UPDATE ${quoteIdent5(oldOp.collection)} SET _field_versions = ? WHERE id = ?`,
-          [serializeFieldVersions(fieldVersions), oldOp.recordId]
-        );
-      }
-      if (oldOp.type === "insert") {
-        await tx.execute(
-          `UPDATE ${quoteIdent5(oldOp.collection)} SET _created_at = ? WHERE id = ? AND _created_at = ?`,
-          [newOp.timestamp.wallTime, oldOp.recordId, oldOp.timestamp.wallTime]
-        );
-      }
-    }
-  });
-  const newMaxTimestamp = newTimestamps[newTimestamps.length - 1] ?? null;
-  return {
-    operations: newOperations,
-    idMapping,
-    rebasedCount: newOperations.length,
-    newMaxTimestamp
-  };
-}
-
-// src/transaction/transaction-context.ts
-import {
-  createOperation as createOperation2,
-  generateUUIDv7,
-  isAtomicOp,
-  quoteIdent as quoteIdent6,
-  resolveAtomicOp,
-  toAtomicOp,
-  validateRecord
-} from "@korajs/core";
-var TransactionContext = class {
-  transactionId;
-  mutationName;
-  buffer = [];
-  committed = false;
-  rolledBack = false;
-  config;
-  constructor(config) {
-    this.config = config;
-    this.transactionId = generateUUIDv7();
-  }
-  /**
-   * Set a human-readable mutation name for this transaction.
-   * Propagated to all operations for DevTools display.
-   */
-  setMutationName(name) {
-    this.mutationName = name;
-  }
-  /**
-   * Get the mutation name, if set.
-   */
-  getMutationName() {
-    return this.mutationName;
-  }
-  /**
-   * Get a collection accessor for buffered operations within this transaction.
-   */
-  collection(name) {
-    const definition = this.config.schema.collections[name];
-    if (!definition) {
-      throw new Error(
-        `Unknown collection "${name}". Available: ${Object.keys(this.config.schema.collections).join(", ")}`
-      );
-    }
-    return {
-      insert: (data) => this.insert(name, definition, data),
-      update: (id, data) => this.update(name, definition, id, data),
-      delete: (id) => this.deleteRecord(name, definition, id),
-      findById: (id) => this.findById(name, definition, id)
-    };
-  }
-  /**
-   * Commit all buffered operations atomically.
-   * Returns the list of operations and affected collections for subscription notification.
-   */
-  async commit() {
-    if (this.committed) {
-      throw new Error("Transaction already committed.");
-    }
-    if (this.rolledBack) {
-      throw new Error("Transaction was rolled back and cannot be committed.");
-    }
-    this.committed = true;
-    if (this.buffer.length === 0) {
-      return { operations: [], affectedCollections: /* @__PURE__ */ new Set() };
-    }
-    const handler = this.config.localMutationHandler;
-    if (handler?.commitTransaction) {
-      return handler.commitTransaction({
-        entries: this.buffer.map((entry) => ({
-          operation: entry.operation,
-          commands: entry.commands,
-          collection: entry.collection
-        })),
-        transactionId: this.transactionId,
-        ...this.mutationName !== void 0 ? { mutationName: this.mutationName } : {}
-      });
-    }
-    const operations = [];
-    const affectedCollections = /* @__PURE__ */ new Set();
-    await this.config.adapter.transaction(async (tx) => {
-      for (const entry of this.buffer) {
-        if (entry.operation.type === "delete" && this.config.relationEnforcer) {
-          const cascadeResult = await this.config.relationEnforcer.enforceDelete(
-            entry.collection,
-            entry.operation.recordId,
-            tx,
-            [entry.operation.id]
-          );
-          for (const cascadedOp of cascadeResult.operations) {
-            operations.push(cascadedOp);
-            affectedCollections.add(cascadedOp.collection);
-            this.config.causalTracker?.afterOperation(cascadedOp.collection, cascadedOp.id, true);
-          }
-        }
-        for (const cmd of entry.commands) {
-          await tx.execute(cmd.sql, cmd.params);
-        }
-        operations.push(entry.operation);
-        affectedCollections.add(entry.collection);
-      }
-      const finalSeq = this.config.sequenceAllocator.getHighWaterMark();
-      if (finalSeq > 0) {
-        await tx.execute(
-          "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-          [this.config.nodeId, finalSeq]
-        );
-      }
-    });
-    return { operations, affectedCollections };
-  }
-  /**
-   * Mark the transaction as rolled back. No operations will be committed.
-   */
-  rollback() {
-    this.rolledBack = true;
-    this.buffer.length = 0;
-  }
-  /**
-   * Get the transaction ID shared by all operations in this transaction.
-   */
-  getTransactionId() {
-    return this.transactionId;
-  }
-  ensureActive() {
-    if (this.committed) {
-      throw new Error("Cannot perform operations on a committed transaction.");
-    }
-    if (this.rolledBack) {
-      throw new Error("Cannot perform operations on a rolled-back transaction.");
-    }
-  }
-  async insert(collectionName, definition, data) {
-    this.ensureActive();
-    const validated = validateRecord(collectionName, definition, data, "insert");
-    const recordId = generateUUIDv7();
-    const now = Date.now();
-    for (const [fieldName, descriptor] of Object.entries(definition.fields)) {
-      if (descriptor.auto && descriptor.kind === "timestamp") {
-        validated[fieldName] = now;
-      }
-    }
-    const sequenceNumber = await this.config.sequenceAllocator.allocate();
-    const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
-    const operation = await createOperation2(
-      {
-        nodeId: this.config.nodeId,
-        type: "insert",
-        collection: collectionName,
-        recordId,
-        // Binary richtext values are tagged as canonical JSON before the
-        // operation is content-hashed (see encodeRichtextFieldsForOpData).
-        data: encodeRichtextFieldsForOpData(validated, definition.fields),
-        previousData: null,
-        sequenceNumber,
-        causalDeps,
-        schemaVersion: this.config.schema.version,
-        transactionId: this.transactionId,
-        ...this.mutationName !== void 0 ? { mutationName: this.mutationName } : {}
-      },
-      this.config.clock
-    );
-    this.config.causalTracker?.afterOperation(collectionName, operation.id, true);
-    const serializedData = serializeRecord(validated, definition.fields);
-    const version = serializeRowVersion(operation.timestamp);
-    const record = {
-      id: recordId,
-      ...serializedData,
-      _created_at: operation.timestamp.wallTime,
-      _updated_at: operation.timestamp.wallTime,
-      _version: version
-    };
-    const insertQuery = buildInsertQuery(collectionName, record);
-    const opRow = serializeOperation(operation);
-    const opInsert = buildInsertQuery(
-      `_kora_ops_${collectionName}`,
-      opRow
-    );
-    this.buffer.push({
-      operation,
-      collection: collectionName,
-      commands: [
-        { sql: insertQuery.sql, params: insertQuery.params },
-        { sql: opInsert.sql, params: opInsert.params }
-      ]
-    });
-    return {
-      id: recordId,
-      ...validated,
-      createdAt: now,
-      updatedAt: now
-    };
-  }
-  async update(collectionName, definition, id, data) {
-    this.ensureActive();
-    const currentRecord = await this.getEffectiveRecord(collectionName, definition, id);
-    if (!currentRecord) {
-      throw new RecordNotFoundError(collectionName, id);
-    }
-    const validated = validateRecord(collectionName, definition, data, "update");
-    const now = Date.now();
-    const previousData = {};
-    const resolvedData = {};
-    const atomicOps = {};
-    for (const key of Object.keys(validated)) {
-      const value = validated[key];
-      previousData[key] = currentRecord[key];
-      if (isAtomicOp(value)) {
-        resolvedData[key] = resolveAtomicOp(currentRecord[key], value);
-        atomicOps[key] = toAtomicOp(value);
-      } else {
-        resolvedData[key] = value;
-      }
-    }
-    const hasAtomicOps = Object.keys(atomicOps).length > 0;
-    const sequenceNumber = await this.config.sequenceAllocator.allocate();
-    const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
-    const operation = await createOperation2(
-      {
-        nodeId: this.config.nodeId,
-        type: "update",
-        collection: collectionName,
-        recordId: id,
-        // Binary richtext values (new and previous) are tagged as canonical
-        // JSON before the operation is content-hashed.
-        data: encodeRichtextFieldsForOpData(resolvedData, definition.fields),
-        previousData: encodeRichtextFieldsForOpData(previousData, definition.fields),
-        sequenceNumber,
-        causalDeps,
-        schemaVersion: this.config.schema.version,
-        transactionId: this.transactionId,
-        ...this.mutationName !== void 0 ? { mutationName: this.mutationName } : {},
-        ...hasAtomicOps ? { atomicOps } : {}
-      },
-      this.config.clock
-    );
-    this.config.causalTracker?.afterOperation(collectionName, operation.id, true);
-    const serializedChanges = serializeRecord(resolvedData, definition.fields);
-    const version = serializeRowVersion(operation.timestamp);
-    const updateQuery = buildUpdateQuery(collectionName, id, {
-      ...serializedChanges,
-      _updated_at: operation.timestamp.wallTime,
-      _version: version
-    });
-    const opRow = serializeOperation(operation);
-    const opInsert = buildInsertQuery(
-      `_kora_ops_${collectionName}`,
-      opRow
-    );
-    this.buffer.push({
-      operation,
-      collection: collectionName,
-      commands: [
-        { sql: updateQuery.sql, params: updateQuery.params },
-        { sql: opInsert.sql, params: opInsert.params }
-      ]
-    });
-    return {
-      ...currentRecord,
-      ...resolvedData,
-      updatedAt: now
-    };
-  }
-  async deleteRecord(collectionName, definition, id) {
-    this.ensureActive();
-    const currentRecord = await this.getEffectiveRecord(collectionName, definition, id);
-    if (!currentRecord) {
-      throw new RecordNotFoundError(collectionName, id);
-    }
-    const now = Date.now();
-    const sequenceNumber = await this.config.sequenceAllocator.allocate();
-    const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
-    const operation = await createOperation2(
-      {
-        nodeId: this.config.nodeId,
-        type: "delete",
-        collection: collectionName,
-        recordId: id,
-        data: null,
-        previousData: null,
-        sequenceNumber,
-        causalDeps,
-        schemaVersion: this.config.schema.version,
-        transactionId: this.transactionId,
-        ...this.mutationName !== void 0 ? { mutationName: this.mutationName } : {}
-      },
-      this.config.clock
-    );
-    this.config.causalTracker?.afterOperation(collectionName, operation.id, true);
-    const deleteQuery = buildSoftDeleteQuery(collectionName, id, now);
-    const opRow = serializeOperation(operation);
-    const opInsert = buildInsertQuery(
-      `_kora_ops_${collectionName}`,
-      opRow
-    );
-    this.buffer.push({
-      operation,
-      collection: collectionName,
-      commands: [
-        { sql: deleteQuery.sql, params: deleteQuery.params },
-        { sql: opInsert.sql, params: opInsert.params }
-      ]
-    });
-  }
-  async findById(collectionName, definition, id) {
-    return this.getEffectiveRecord(collectionName, definition, id);
-  }
-  /**
-   * Get the effective state of a record, considering both the database and buffered operations.
-   * Buffered inserts/updates take precedence over the database state.
-   */
-  async getEffectiveRecord(collectionName, definition, id) {
-    for (let i = this.buffer.length - 1; i >= 0; i--) {
-      const entry = this.buffer[i];
-      if (entry.collection === collectionName && entry.operation.recordId === id) {
-        if (entry.operation.type === "delete") {
-          return null;
-        }
-        break;
-      }
-    }
-    const rows = await this.config.adapter.query(
-      `SELECT * FROM ${quoteIdent6(collectionName)} WHERE id = ? AND _deleted = 0`,
-      [id]
-    );
-    let record = rows[0] ? deserializeRecord(rows[0], definition.fields) : null;
-    for (const entry of this.buffer) {
-      if (entry.collection !== collectionName || entry.operation.recordId !== id) {
-        continue;
-      }
-      if (entry.operation.type === "insert" && entry.operation.data) {
-        record = {
-          id,
-          // op.data stores binary richtext as tagged JSON; the effective
-          // record must expose record-shaped values (Uint8Array/string).
-          ...decodeRichtextFieldsFromOpData(entry.operation.data, definition.fields),
-          createdAt: entry.operation.timestamp.wallTime,
-          updatedAt: entry.operation.timestamp.wallTime
-        };
-      } else if (entry.operation.type === "update" && entry.operation.data && record) {
-        record = {
-          ...record,
-          ...decodeRichtextFieldsFromOpData(entry.operation.data, definition.fields),
-          updatedAt: entry.operation.timestamp.wallTime
-        };
-      } else if (entry.operation.type === "delete") {
-        record = null;
-      }
-    }
-    return record;
-  }
-};
-
-// src/transaction/transaction-sequence.ts
-var TransactionSequenceAllocator = class {
-  constructor(adapter, nodeId) {
-    this.adapter = adapter;
-    this.nodeId = nodeId;
-  }
-  adapter;
-  nodeId;
-  loaded = false;
-  watermark = 0;
-  async allocate() {
-    if (!this.loaded) {
-      this.watermark = await readSequenceNumber(this.adapter, this.nodeId);
-      this.loaded = true;
-    }
-    this.watermark++;
-    return this.watermark;
-  }
-  getHighWaterMark() {
-    return this.watermark;
-  }
-};
-
-// src/store/tab-node-id.ts
-import { generateUUIDv7 as generateUUIDv72 } from "@korajs/core";
-function perTabStorageKey(dbName) {
-  return `kora-tab-node-${dbName}`;
-}
-function loadPerTabNodeId(dbName) {
-  if (typeof sessionStorage === "undefined") {
-    return null;
-  }
-  return sessionStorage.getItem(perTabStorageKey(dbName));
-}
-function savePerTabNodeId(dbName, nodeId) {
-  if (typeof sessionStorage === "undefined") {
-    return;
-  }
-  sessionStorage.setItem(perTabStorageKey(dbName), nodeId);
-}
-function resolvePerTabNodeId(dbName) {
-  const existing = loadPerTabNodeId(dbName);
-  if (existing) {
-    return existing;
-  }
-  const nodeId = generateUUIDv72();
-  savePerTabNodeId(dbName, nodeId);
-  return nodeId;
-}
-
-// src/store/store.ts
-var Store = class {
-  opened = false;
-  nodeId = "";
-  sequenceNumber = 0;
-  versionVector = createVersionVector3();
-  clock = null;
-  collections = /* @__PURE__ */ new Map();
-  subscriptionManager;
-  sequenceManager = null;
-  schema;
-  adapter;
-  configNodeId;
-  dbName;
-  isolation;
-  emitter;
-  localMutationHandler;
-  relationEnforcer = null;
-  causalTracker = null;
-  secretKeyProvider;
-  constructor(config) {
-    this.schema = config.schema;
-    this.adapter = config.adapter;
-    this.configNodeId = config.nodeId;
-    this.dbName = config.dbName ?? "kora-db";
-    this.isolation = config.isolation ?? "shared";
-    this.emitter = config.emitter ?? null;
-    this.localMutationHandler = config.localMutationHandler ?? null;
-    this.secretKeyProvider = config.secretKeyProvider;
-    this.subscriptionManager = new SubscriptionManager({
-      onQuerySubscribed: config.onQuerySubscribed
-    });
-  }
-  /**
-   * Open the store: initialize the database, load or generate a node ID,
-   * restore the sequence number and version vector, and create Collection instances.
-   */
-  async open() {
-    await this.adapter.open(this.schema);
-    await this.adapter.execute(
-      "CREATE TABLE IF NOT EXISTS _kora_scope_retractions (collection TEXT NOT NULL, record_id TEXT NOT NULL, PRIMARY KEY (collection, record_id))"
-    );
-    await this.runMigrationsIfNeeded();
-    this.nodeId = await this.loadOrGenerateNodeId();
-    this.clock = new HybridLogicalClock3(this.nodeId);
-    this.causalTracker = new CausalTracker();
-    this.sequenceManager = new SequenceManager(this.adapter, this.nodeId);
-    this.sequenceNumber = await this.loadSequenceNumber();
-    this.versionVector = await this.loadVersionVector();
-    const hasRelations = Object.keys(this.schema.relations).length > 0;
-    this.relationEnforcer = hasRelations ? new RelationEnforcer({
-      schema: this.schema,
-      adapter: this.adapter,
-      clock: this.clock,
-      nodeId: this.nodeId
-    }) : null;
-    for (const [name, definition] of Object.entries(this.schema.collections)) {
-      const col = new Collection(
-        name,
-        definition,
-        this.schema,
-        this.adapter,
-        this.clock,
-        this.nodeId,
-        () => this.allocateSequenceNumber(),
-        (collectionName, operation) => {
-          this.recordOperationSequence(operation);
-          this.subscriptionManager.notify(collectionName, operation);
-          if (this.emitter) {
-            this.emitter.emit({ type: "operation:created", operation });
-          }
-        },
-        this.relationEnforcer,
-        this.localMutationHandler,
-        this.causalTracker,
-        this.secretKeyProvider
-      );
-      this.collections.set(name, col);
-    }
-    this.opened = true;
-  }
-  /**
-   * Close the store: clear subscriptions and close the adapter.
-   */
-  async close() {
-    this.subscriptionManager.clear();
-    this.collections.clear();
-    this.opened = false;
-    await this.adapter.close();
-  }
-  /**
-   * Get a Collection instance for CRUD operations.
-   * @throws {StoreNotOpenError} If the store is not open
-   * @throws {Error} If the collection name is not in the schema
-   */
-  collection(name) {
-    this.ensureOpen();
-    const col = this.collections.get(name);
-    if (!col) {
-      throw new Error(
-        `Unknown collection "${name}". Available: ${[...this.collections.keys()].join(", ")}`
-      );
-    }
-    const definition = this.schema.collections[name];
-    if (!definition) {
-      throw new Error(`Collection definition not found for "${name}"`);
-    }
-    return {
-      insert: (data) => col.insert(data),
-      findById: (id) => col.findById(id),
-      update: (id, data) => col.update(id, data),
-      delete: (id) => col.delete(id),
-      where: (conditions) => new QueryBuilder(
-        name,
-        definition,
-        this.adapter,
-        this.subscriptionManager,
-        conditions,
-        this.schema
-      )
-    };
-  }
-  /**
-   * Get the current version vector.
-   */
-  getVersionVector() {
-    this.ensureOpen();
-    return new Map(this.versionVector);
-  }
-  /**
-   * Get the node ID for this store instance.
-   */
-  /**
-   * Records the offset between server time and this device's clock
-   * (serverTime - localTime), learned at sync handshake. Lets the store's HLC
-   * validate remote timestamps correctly even when the local clock is wrong.
-   */
-  setClockReferenceOffset(offsetMs) {
-    this.clock?.setReferenceOffset(offsetMs);
-  }
-  getNodeId() {
-    this.ensureOpen();
-    return this.nodeId;
-  }
-  /**
-   * Apply a remote operation received from sync.
-   * Checks for duplicates, applies to the data table, persists the operation,
-   * and updates the version vector.
-   */
-  async applyRemoteOperation(op, options) {
-    this.ensureOpen();
-    const collection = op.collection;
-    const definition = this.schema.collections[collection];
-    if (!definition) {
-      return "skipped";
-    }
-    const existing = await this.adapter.query(
-      `SELECT id FROM ${quoteIdent7(`_kora_ops_${collection}`)} WHERE id = ?`,
-      [op.id]
-    );
-    if (existing.length > 0) {
-      const retracted = await this.adapter.query(
-        "SELECT record_id FROM _kora_scope_retractions WHERE collection = ? AND record_id = ?",
-        [collection, op.recordId]
-      );
-      if (retracted.length > 0) {
-        await this.adapter.transaction(async (tx) => {
-          await tx.execute(`UPDATE ${quoteIdent7(collection)} SET _deleted = 0 WHERE id = ?`, [
-            op.recordId
-          ]);
-          await tx.execute(
-            "DELETE FROM _kora_scope_retractions WHERE collection = ? AND record_id = ?",
-            [collection, op.recordId]
-          );
-        });
-        this.subscriptionManager.invalidate(collection);
-      }
-      return "duplicate";
-    }
-    if (this.clock) {
-      this.clock.receive(op.timestamp);
-    }
-    const materializeTimestamp = options?.materializeTimestamp ?? op.timestamp;
-    const remoteVersion = serializeRowVersion(materializeTimestamp);
-    const wallTime = materializeTimestamp.wallTime;
-    const materializeSource = options?.materializeData ?? op.data;
-    await this.adapter.transaction(async (tx) => {
-      const checkGuard = (row) => {
-        const guard = options?.guardRowState;
-        if (!guard) {
-          return;
-        }
-        const version = typeof row?._version === "string" ? row._version : null;
-        const fieldVersions = typeof row?._field_versions === "string" ? row._field_versions : null;
-        if (version !== guard.version || fieldVersions !== guard.fieldVersions) {
-          throw new OptimisticLockError(collection, op.recordId);
-        }
-      };
-      if (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 = ?`,
-          [op.recordId]
-        );
-        const row = existing2[0];
-        checkGuard(row);
-        if (!row) {
-          const record = {
-            id: op.recordId,
-            ...serializedData,
-            _created_at: wallTime,
-            _updated_at: wallTime,
-            _version: remoteVersion,
-            // Stamp every inserted field so per-field LWW has a real baseline.
-            _field_versions: serializeFieldVersions(
-              fieldVersionsForFields(Object.keys(serializedData), remoteVersion)
-            )
-          };
-          const insertQuery = buildInsertQuery(collection, record);
-          await tx.execute(insertQuery.sql, insertQuery.params);
-          await this.foldOrphanedOperations(tx, collection, definition, op.recordId, op);
-        } else if (row._deleted === 1) {
-          if (isIncomingNewerThanRow(materializeTimestamp, row)) {
-            const fieldChanges = {
-              ...serializedData,
-              _deleted: 0,
-              _field_versions: serializeFieldVersions(
-                fieldVersionsForFields(Object.keys(serializedData), remoteVersion)
-              )
-            };
-            const upsert = buildFieldFastForwardUpdateQuery(
-              collection,
-              op.recordId,
-              fieldChanges,
-              remoteVersion,
-              wallTime,
-              { maxCreatedAt: wallTime }
-            );
-            await tx.execute(upsert.sql, upsert.params);
-          }
-        } else {
-          const currentVersions = parseFieldVersions(row._field_versions);
-          const rowVersion = typeof row._version === "string" ? row._version : void 0;
-          const fieldChanges = {};
-          let fieldVersionsJson;
-          if (options?.forceMaterialize) {
-            const merged = { ...currentVersions };
-            for (const field of Object.keys(serializedData)) {
-              fieldChanges[field] = serializedData[field];
-              merged[field] = remoteVersion;
-            }
-            fieldVersionsJson = serializeFieldVersions(merged);
-          } else {
-            const { winners, merged } = resolvePerFieldLww(
-              currentVersions,
-              Object.keys(serializedData),
-              remoteVersion,
-              rowVersion
-            );
-            for (const field of winners) {
-              fieldChanges[field] = serializedData[field];
-            }
-            fieldVersionsJson = serializeFieldVersions(merged);
-          }
-          const upsert = buildFieldFastForwardUpdateQuery(
-            collection,
-            op.recordId,
-            { ...fieldChanges, _field_versions: fieldVersionsJson },
-            remoteVersion,
-            wallTime,
-            { maxCreatedAt: wallTime }
-          );
-          await tx.execute(upsert.sql, upsert.params);
-        }
-      } else if (op.type === "update" && materializeSource) {
-        const serializedChanges = serializeRecord(materializeSource, definition.fields);
-        const changedFields = Object.keys(serializedChanges);
-        const currentRows = await tx.query(
-          `SELECT _version, _field_versions FROM ${quoteIdent7(collection)} WHERE id = ?`,
-          [op.recordId]
-        );
-        const currentRow = currentRows[0];
-        checkGuard(currentRow);
-        if (currentRow) {
-          const currentVersions = parseFieldVersions(currentRow._field_versions);
-          const rowVersion = typeof currentRow._version === "string" ? currentRow._version : void 0;
-          if (options?.forceMaterialize) {
-            const merged = { ...currentVersions };
-            for (const field of changedFields) {
-              merged[field] = remoteVersion;
-            }
-            const fieldChanges = {
-              ...serializedChanges,
-              _field_versions: serializeFieldVersions(merged)
-            };
-            if (options?.reactivateIfDeleted) {
-              fieldChanges._deleted = 0;
-            }
-            const forceQuery = buildFieldFastForwardUpdateQuery(
-              collection,
-              op.recordId,
-              fieldChanges,
-              remoteVersion,
-              wallTime
-            );
-            await tx.execute(forceQuery.sql, forceQuery.params);
-          } else {
-            const { winners, merged } = resolvePerFieldLww(
-              currentVersions,
-              changedFields,
-              remoteVersion,
-              rowVersion
-            );
-            if (winners.length > 0 || options?.reactivateIfDeleted) {
-              const winningChanges = {
-                _field_versions: serializeFieldVersions(merged)
-              };
-              for (const field of winners) {
-                winningChanges[field] = serializedChanges[field];
-              }
-              if (options?.reactivateIfDeleted) {
-                winningChanges._deleted = 0;
-              }
-              const forceQuery = buildFieldFastForwardUpdateQuery(
-                collection,
-                op.recordId,
-                winningChanges,
-                remoteVersion,
-                wallTime
-              );
-              await tx.execute(forceQuery.sql, forceQuery.params);
-            }
-          }
-        }
-      } else if (op.type === "delete") {
-        const deleteQuery = buildLwwSoftDeleteQuery(
-          collection,
-          op.recordId,
-          wallTime,
-          remoteVersion
-        );
-        await tx.execute(deleteQuery.sql, deleteQuery.params);
-      }
-      const opRow = serializeOperation(op);
-      const opInsert = buildInsertQuery(
-        `_kora_ops_${collection}`,
-        opRow
-      );
-      await tx.execute(opInsert.sql, opInsert.params);
-      const currentSeq = this.versionVector.get(op.nodeId) ?? 0;
-      if (op.sequenceNumber > currentSeq) {
-        this.versionVector.set(op.nodeId, op.sequenceNumber);
-        await tx.execute(
-          "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-          [op.nodeId, op.sequenceNumber]
-        );
-      }
-    });
-    this.subscriptionManager.notify(collection, op);
-    return "applied";
-  }
-  /**
-   * Hide a record from this client's authorized materialized view. This writes no
-   * replicated operation and therefore cannot be mistaken for a domain deletion.
-   * The marker lets a later authoritative backfill reactivate the retained row.
-   */
-  async applyScopeRetraction(collection, recordId) {
-    this.ensureOpen();
-    if (!this.schema.collections[collection]) return;
-    await this.adapter.transaction(async (tx) => {
-      await tx.execute(`UPDATE ${quoteIdent7(collection)} SET _deleted = 1 WHERE id = ?`, [recordId]);
-      await tx.execute(
-        "INSERT OR REPLACE INTO _kora_scope_retractions (collection, record_id) VALUES (?, ?)",
-        [collection, recordId]
-      );
-    });
-    this.subscriptionManager.invalidate(collection);
-  }
-  /** Hide all live rows that no longer match a newly accepted server scope. */
-  async applyScopeNarrowing(scopes) {
-    this.ensureOpen();
-    const retractions = [];
-    for (const [collection, definition] of Object.entries(this.schema.collections)) {
-      const rows = await this.adapter.query(
-        `SELECT * FROM ${quoteIdent7(collection)} WHERE _deleted = 0`
-      );
-      const predicate = scopes[collection];
-      for (const row of rows) {
-        const record = deserializeRecord(row, definition.fields);
-        const matches = predicate !== void 0 && Object.entries(predicate).every(([field, expected]) => {
-          if (expected && typeof expected === "object" && !Array.isArray(expected) && "$in" in expected) {
-            const values = expected.$in;
-            return Array.isArray(values) && values.some((value) => Object.is(record[field], value));
-          }
-          return Object.is(record[field], expected);
-        });
-        if (!matches) {
-          await this.applyScopeRetraction(collection, String(record.id));
-          retractions.push({ collection, recordId: String(record.id) });
-        }
-      }
-    }
-    return retractions;
-  }
-  /**
-   * Materialize update/delete operations that were logged for a record BEFORE
-   * its insert arrived (reordered delivery). Runs inside the insert's write
-   * transaction, folding each orphan in timestamp order through the exact
-   * per-field LWW / LWW-delete rules the normal apply paths use, so the final
-   * row state equals what a device that received the operations in causal
-   * order computed. Called only when the insert created a previously-absent
-   * row — in that case every logged update/delete for the record is
-   * necessarily an orphan (rows are soft-deleted, never removed, so a row
-   * that is absent now was never materialized).
-   */
-  async foldOrphanedOperations(tx, collection, definition, recordId, insertOp) {
-    const orphanRows = await tx.query(
-      `SELECT * FROM ${quoteIdent7(`_kora_ops_${collection}`)} WHERE record_id = ? AND type IN ('update', 'delete')`,
-      [recordId]
-    );
-    if (orphanRows.length === 0) {
-      return;
-    }
-    const orphans = orphanRows.map((r) => deserializeOperationWithCollection(r, collection)).sort((a, b) => HybridLogicalClock3.compare(a.timestamp, b.timestamp));
-    for (const orphan of orphans) {
-      const orphanVersion = serializeRowVersion(orphan.timestamp);
-      const orphanWall = orphan.timestamp.wallTime;
-      if (orphan.type === "update" && orphan.data) {
-        const orphanChanges = serializeRecord(orphan.data, definition.fields);
-        const rows = await tx.query(
-          `SELECT _version, _field_versions FROM ${quoteIdent7(collection)} WHERE id = ?`,
-          [recordId]
-        );
-        const current = rows[0];
-        if (!current) {
-          continue;
-        }
-        const { winners, merged } = resolvePerFieldLww(
-          parseFieldVersions(current._field_versions),
-          Object.keys(orphanChanges),
-          orphanVersion,
-          typeof current._version === "string" ? current._version : void 0
-        );
-        if (winners.length > 0) {
-          const winningChanges = {
-            _field_versions: serializeFieldVersions(merged)
-          };
-          for (const field of winners) {
-            winningChanges[field] = orphanChanges[field];
-          }
-          const query = buildFieldFastForwardUpdateQuery(
-            collection,
-            recordId,
-            winningChanges,
-            orphanVersion,
-            orphanWall
-          );
-          await tx.execute(query.sql, query.params);
-        }
-      } else if (orphan.type === "delete") {
-        const query = buildLwwSoftDeleteQuery(collection, recordId, orphanWall, orphanVersion);
-        await tx.execute(query.sql, query.params);
-      }
-    }
-    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.
-   * Implements the OperationLog interface for computeDelta.
-   */
-  async getRange(nodeId, fromSeq, toSeq) {
-    return this.getOperationRange(nodeId, fromSeq, toSeq);
-  }
-  /**
-   * Get operations from a node within a sequence number range.
-   */
-  async getOperationRange(nodeId, fromSeq, toSeq) {
-    this.ensureOpen();
-    const allOps = [];
-    for (const collectionName of Object.keys(this.schema.collections)) {
-      const rows = await this.adapter.query(
-        `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) {
-        allOps.push(deserializeOperationWithCollection(row, collectionName));
-      }
-    }
-    allOps.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
-    return allOps;
-  }
-  /**
-   * Load every operation from the local append-only log across all collections.
-   * Used by sync delta computation, backup export, and time-travel replay.
-   */
-  async getAllOperations() {
-    this.ensureOpen();
-    const allOps = [];
-    for (const collectionName of Object.keys(this.schema.collections)) {
-      const rows = await this.adapter.query(
-        `SELECT * FROM ${quoteIdent7(`_kora_ops_${collectionName}`)} ORDER BY sequence_number ASC`
-      );
-      for (const row of rows) {
-        allOps.push(deserializeOperationWithCollection(row, collectionName));
-      }
-    }
-    return allOps;
-  }
-  /**
-   * Rebuild an in-memory snapshot of materialized state at a causal cut in the op log.
-   * Does not mutate the live store — intended for DevTools time-travel inspection.
-   *
-   * @param operationId - Content-addressed id of the operation to replay through (inclusive)
-   * @throws {OperationError} When the operation id is not present in the local log
-   */
-  async replayTo(operationId) {
-    this.ensureOpen();
-    const start = Date.now();
-    const allOps = await this.getAllOperations();
-    const snapshot = buildReplaySnapshot(this.schema, allOps, operationId);
-    if (this.emitter) {
-      this.emitter.emit({
-        type: "replay:completed",
-        targetOperationId: operationId,
-        operationsApplied: snapshot.operationsApplied.length,
-        duration: Date.now() - start
-      });
-    }
-    return snapshot;
-  }
-  /**
-   * Persist a merge trace to the durable audit log.
-   */
-  async appendAuditTrace(trace) {
-    this.ensureOpen();
-    const { appendAuditTrace: append } = await import("./audit-trace-store-AM4EWQNZ.js");
-    await append(this.adapter, trace);
-  }
-  /**
-   * Read persisted audit traces with optional filters.
-   */
-  async getAuditTraces(query) {
-    this.ensureOpen();
-    const { readAuditTraces: readAuditTraces2 } = await import("./audit-trace-store-AM4EWQNZ.js");
-    return readAuditTraces2(this.adapter, query);
-  }
-  /**
-   * Export operations and merge traces as a portable audit bundle.
-   */
-  async exportAudit(options) {
-    this.ensureOpen();
-    const { exportAudit: doExport } = await import("./export-audit-ODGQTQIK.js");
-    return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
-  }
-  /**
-   * Get the schema definition.
-   */
-  getSchema() {
-    return this.schema;
-  }
-  /**
-   * Route local CRUD through the unified apply pipeline (korajs ApplyPipeline).
-   */
-  setLocalMutationHandler(handler) {
-    this.localMutationHandler = handler;
-    for (const col of this.collections.values()) {
-      col.setMutationHandler(handler);
-    }
-  }
-  /**
-   * 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).
-   */
-  createMutationContext(collection, options) {
-    this.ensureOpen();
-    const definition = this.schema.collections[collection];
-    if (!definition || !this.clock) {
-      throw new StoreNotOpenError();
-    }
-    return {
-      collection,
-      definition,
-      schema: this.schema,
-      adapter: this.adapter,
-      clock: this.clock,
-      nodeId: this.nodeId,
-      allocateSequenceNumber: () => this.allocateSequenceNumber(),
-      onMutation: (collectionName, operation) => {
-        this.recordOperationSequence(operation);
-        this.subscriptionManager.notify(collectionName, operation);
-        if (this.emitter) {
-          this.emitter.emit({ type: "operation:created", operation });
-        }
-      },
-      relationEnforcer: this.relationEnforcer,
-      causalTracker: this.causalTracker,
-      inTransaction: options?.inTransaction ?? false,
-      extraCausalDeps: options?.extraCausalDeps,
-      secretKeyProvider: this.secretKeyProvider
-    };
-  }
-  /**
-   * Load a materialized row by ID, including soft-deleted tombstones.
-   */
-  async findMaterializedRow(collection, recordId) {
-    this.ensureOpen();
-    const definition = this.schema.collections[collection];
-    if (!definition) {
-      return null;
-    }
-    const rows = await this.adapter.query(
-      `SELECT * FROM ${quoteIdent7(collection)} WHERE id = ?`,
-      [recordId]
-    );
-    const row = rows[0];
-    if (!row) {
-      return null;
-    }
-    return {
-      record: deserializeRecord(row, definition.fields),
-      deleted: row._deleted === 1
-    };
-  }
-  /**
-   * Raw version state of a materialized row, for optimistic-concurrency guarded
-   * applies: capture this snapshot before computing a merge, pass it as
-   * `guardRowState`, and the apply refuses to write if the row changed since.
-   * Returns null when no row exists (which is itself a valid guard state — the
-   * apply then requires the row to still be absent).
-   */
-  async getRowVersionState(collection, recordId) {
-    this.ensureOpen();
-    if (!this.schema.collections[collection]) {
-      return null;
-    }
-    const rows = await this.adapter.query(
-      `SELECT _version, _field_versions FROM ${quoteIdent7(collection)} WHERE id = ?`,
-      [recordId]
-    );
-    const row = rows[0];
-    if (!row) {
-      return null;
-    }
-    return {
-      version: typeof row._version === "string" ? row._version : null,
-      fieldVersions: typeof row._field_versions === "string" ? row._field_versions : null
-    };
-  }
-  /**
-   * Latest operation from this device for a record (used for delete-vs-update merge on sync).
-   */
-  /**
-   * Load the last server version vector acknowledged by this client (persisted in `_kora_meta`).
-   */
-  async loadLastAckedServerVector() {
-    this.ensureOpen();
-    return loadLastAckedServerVector(this.adapter);
-  }
-  /**
-   * Persist the last server version vector this client believes the server has applied.
-   */
-  async saveLastAckedServerVector(vector) {
-    this.ensureOpen();
-    await saveLastAckedServerVector(this.adapter, vector);
-  }
-  /**
-   * Load persisted delta cursor for resuming paginated initial sync.
-   */
-  async loadDeltaCursor() {
-    this.ensureOpen();
-    return loadDeltaCursor(this.adapter);
-  }
-  /**
-   * Persist or clear the delta cursor for paginated initial sync resume.
-   */
-  async saveDeltaCursor(cursor) {
-    this.ensureOpen();
-    await saveDeltaCursor(this.adapter, cursor);
-  }
-  /**
-   * 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.
-   */
-  async getUnsyncedOperations(serverVector) {
-    this.ensureOpen();
-    return collectOperationsAheadOfServer(
-      this.getVersionVector(),
-      serverVector,
-      (nodeId, fromSeq, toSeq) => this.getOperationRange(nodeId, fromSeq, toSeq)
-    );
-  }
-  /**
-   * Re-stamp never-acknowledged local operations after a fast device clock was
-   * corrected, so sync can resume immediately. Safe because unacknowledged
-   * operations are private to this device (like unpushed git commits);
-   * acknowledged/shared operations are immutable and never touched.
-   *
-   * After the rewrite the store's HLC is advanced past the highest new
-   * timestamp so subsequent local writes keep sorting after the rebased ops.
-   * No data-change notifications are emitted: materialized values are
-   * unchanged, only version stamps move.
-   */
-  async rebaseUnsyncedOperations(unsyncedOpIds, correctedNowMs) {
-    this.ensureOpen();
-    const result = await rebaseUnsyncedOperationsInLog(
-      this.adapter,
-      this.schema,
-      unsyncedOpIds,
-      correctedNowMs
-    );
-    if (result.newMaxTimestamp && this.clock) {
-      this.clock.advanceTo(result.newMaxTimestamp);
-    }
-    return result;
-  }
-  /**
-   * Count of local operations ahead of the server version vector.
-   */
-  async countUnsyncedOperations(serverVector) {
-    const ops = await this.getUnsyncedOperations(serverVector);
-    return ops.length;
-  }
-  /**
-   * Compact the local operation log using materialized rows as the baseline.
-   * Only removes ops the server has acknowledged (per {@link CompactionStrategy}).
-   */
-  async compact(strategy) {
-    this.ensureOpen();
-    if (strategy.mode === "never") {
-      return compactOperationLog(this.adapter, this.schema, strategy, createVersionVector3());
-    }
-    const serverVector = strategy.serverVector ?? await loadLastAckedServerVector(this.adapter);
-    return compactOperationLog(this.adapter, this.schema, strategy, serverVector);
-  }
-  /**
-   * Merge session remote vector with persisted last-acked vector (max per node).
-   */
-  mergeServerVectors(sessionVector, persistedVector) {
-    return mergeVersionVectors(persistedVector, sessionVector);
-  }
-  async getLatestLocalOperationForRecord(collection, recordId) {
-    this.ensureOpen();
-    const rows = await this.adapter.query(
-      `SELECT * FROM ${quoteIdent7(`_kora_ops_${collection}`)} WHERE node_id = ? AND record_id = ? ORDER BY sequence_number DESC LIMIT 1`,
-      [this.nodeId, recordId]
-    );
-    const row = rows[0];
-    if (!row) {
-      return null;
-    }
-    return deserializeOperationWithCollection(row, collection);
-  }
-  /**
-   * Latest operation for a record from any node (for 3-way merge when local op log is empty).
-   */
-  async getLatestOperationForRecord(collection, recordId) {
-    this.ensureOpen();
-    const rows = await this.adapter.query(
-      `SELECT * FROM ${quoteIdent7(`_kora_ops_${collection}`)} WHERE record_id = ?`,
-      [recordId]
-    );
-    let latest = null;
-    for (const row of rows) {
-      const op = deserializeOperationWithCollection(row, collection);
-      if (!latest || HybridLogicalClock3.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 ${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;
+  Collection,
+  QueryBuilder,
+  SequenceManager,
+  Store,
+  SubscriptionBloomFilter,
+  SubscriptionManager,
+  TransactionContext,
+  compactOperationLog,
+  computeAckCompactionWatermark,
+  normalizeWhere,
+  pluralize,
+  queryKey,
+  singularize
+} from "./chunk-5AQSGMJV.js";
+import {
+  BlobIntegrityError,
+  MemoryBlobStore
+} from "./chunk-W4MTTNEZ.js";
+import {
+  InvalidStateTransitionError,
+  validateStateTransition,
+  validateUpdateStateMachine
+} from "./chunk-BILSA6XZ.js";
+import "./chunk-A6GFH5IG.js";
+import {
+  BACKUP_VERSION,
+  BackupFormatError,
+  COMPACTION_BASELINE_META_KEY,
+  LOG_QUARANTINE_TABLE,
+  convertBackupV1,
+  exportBackup,
+  readBackupManifest,
+  restoreBackup,
+  verifyBackupChecksum
+} from "./chunk-UC2LGFPV.js";
+import {
+  mergeYjsUpdates
+} from "./chunk-KTVNANUH.js";
+import {
+  LAST_ACKED_SERVER_VECTOR_META_KEY,
+  VIRTUAL_TIMESTAMP_FIELDS,
+  VIRTUAL_TIMESTAMP_FIELD_NAMES,
+  collectOperationsAheadOfServer,
+  deserializeVersionVectorFromMeta,
+  mergeVersionVectors,
+  serializeVersionVectorToMeta
+} from "./chunk-QW4UU7NG.js";
+import {
+  decodeRichtext,
+  encodeRichtext,
+  richtextStatesEqual,
+  richtextToPlainText
+} from "./chunk-J5AGXF3D.js";
+import {
+  AdapterError,
+  BridgeTerminatedError,
+  LeaderUnresponsiveError,
+  NoLeaderError,
+  NodeOwnedByAnotherUserError,
+  OptimisticLockError,
+  PersistenceError,
+  QueryError,
+  RecordNotFoundError,
+  RequestAbortedError,
+  SchemaVersionAheadError,
+  StorageBackendMismatchError,
+  StorageDurabilityError,
+  StorageInUseError,
+  StoreNotOpenError,
+  UnsyncedDataError,
+  WorkerInitError,
+  WorkerTimeoutError
+} from "./chunk-SRHDJF5B.js";
+
+// src/persistence/storage-persistence.ts
+function defaultStorageManager() {
+  const nav = globalThis.navigator;
+  return nav?.storage ?? null;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var StoragePersistence = class {
+  current = {
+    state: "unknown",
+    persisted: false,
+    requested: false
+  };
+  inFlightRequest = null;
+  emitter;
+  storageOverride;
+  constructor(options = {}) {
+    this.emitter = options.emitter ?? null;
+    this.storageOverride = options.storage;
   }
-  /**
-   * Get the sequence manager for offline-safe sequence generation.
-   * @throws {StoreNotOpenError} If the store is not open
-   */
-  getSequenceManager() {
-    this.ensureOpen();
-    if (!this.sequenceManager) {
-      throw new StoreNotOpenError();
-    }
-    return this.sequenceManager;
+  /** Synchronous snapshot of the last known state. Never prompts. */
+  status() {
+    return { ...this.current };
   }
   /**
-   * Create a TransactionContext for atomic multi-collection operations.
-   * The returned context buffers all mutations and commits them atomically.
-   *
-   * After commit, the caller is responsible for notifying subscriptions
-   * and emitting events for each operation.
+   * Read whether storage is already persistent (`navigator.storage.persisted()`).
+   * Never prompts and never throws: a failure becomes `state: 'error'`.
    */
-  createTransaction() {
-    this.ensureOpen();
-    if (!this.clock) {
-      throw new StoreNotOpenError();
+  async check() {
+    const storage = this.storage();
+    if (!storage || typeof storage.persisted !== "function") {
+      this.update({ state: "unsupported", persisted: false });
+      if (storage) this.emit("unsupported", false);
+      return this.status();
     }
-    return new TransactionContext({
-      schema: this.schema,
-      adapter: this.adapter,
-      clock: this.clock,
-      nodeId: this.nodeId,
-      sequenceAllocator: new TransactionSequenceAllocator(this.adapter, this.nodeId),
-      relationEnforcer: this.relationEnforcer,
-      causalTracker: this.causalTracker,
-      localMutationHandler: this.localMutationHandler
-    });
-  }
-  /**
-   * Execute a function within a transaction. All mutations performed on the
-   * TransactionContext are committed atomically. Subscription notifications
-   * are batched and fired after the commit.
-   *
-   * If the function throws, the transaction is rolled back and the error is re-thrown.
-   *
-   * @param fn - Function receiving a TransactionContext for buffered operations
-   * @returns The operations that were committed
-   */
-  async transaction(fn) {
-    const tx = this.createTransaction();
-    this.causalTracker?.beginTransaction();
     try {
-      await fn(tx);
-      const { operations } = await tx.commit();
-      this.causalTracker?.clearTransaction();
-      for (const op of operations) {
-        this.recordOperationSequence(op);
-        this.subscriptionManager.notify(op.collection, op);
-        if (this.emitter) {
-          this.emitter.emit({ type: "operation:created", operation: op });
-        }
+      const persisted = await storage.persisted() === true;
+      if (!this.current.persisted) {
+        this.update({ state: persisted ? "persisted" : "best-effort", persisted });
       }
-      return operations;
+      this.emit("checked", this.current.persisted);
     } catch (error) {
-      tx.rollback();
-      this.causalTracker?.clearTransaction();
-      throw error;
+      this.update({ state: "error", persisted: false, lastError: errorMessage(error) });
+      this.emit("error", false, errorMessage(error));
     }
+    return this.status();
   }
   /**
-   * Export all data as a portable backup binary.
-   * Includes operations, version vector, metadata, and optionally materialized records.
-   *
-   * @param options - Backup options (includeRecords, collections, onProgress)
-   * @returns Backup as a Uint8Array
-   */
-  async exportBackup(options) {
-    this.ensureOpen();
-    const { exportBackup: doExport } = await import("./backup-5S7K2Z35.js");
-    return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
-  }
-  /**
-   * Restore data from a backup binary.
+   * Ask the browser for persistent storage (`navigator.storage.persist()`).
+   * May show a permission prompt (Firefox), so call it from a user gesture or a
+   * meaningful moment, and do not block rendering on it. Concurrent calls share
+   * one request. Never throws: a failure becomes `state: 'error'`.
    *
-   * @param data - The backup data
-   * @param options - Restore options (merge, collections, onProgress)
-   * @returns Result of the restore operation
-   */
-  async importBackup(data, options) {
-    this.ensureOpen();
-    const { restoreBackup: doRestore } = await import("./backup-5S7K2Z35.js");
-    return doRestore(this.adapter, this.schema, data, options);
+   * @returns The state after the browser answered
+   */
+  request() {
+    if (this.inFlightRequest) return this.inFlightRequest;
+    const storage = this.storage();
+    if (!storage || typeof storage.persist !== "function") {
+      this.update({ state: "unsupported", persisted: false });
+      if (storage) this.emit("unsupported", false);
+      return Promise.resolve(this.status());
+    }
+    if (this.current.persisted) return Promise.resolve(this.status());
+    const persist = storage.persist.bind(storage);
+    this.current = { ...this.current, requested: true };
+    const pending = (async () => {
+      try {
+        const persisted = await persist() === true;
+        this.update({ state: persisted ? "persisted" : "best-effort", persisted });
+        this.emit("requested", persisted);
+      } catch (error) {
+        this.update({ state: "error", persisted: false, lastError: errorMessage(error) });
+        this.emit("error", false, errorMessage(error));
+      } finally {
+        this.inFlightRequest = null;
+      }
+      return this.status();
+    })();
+    this.inFlightRequest = pending;
+    return pending;
   }
   /**
-   * Read backup manifest without loading the entire backup.
+   * Fire-and-forget `request()` for an automatic trigger. Never awaited by Kora,
+   * so a pending prompt cannot block anything; the outcome arrives as a
+   * `storage:persistence` event. Skipped when storage is already persistent or a
+   * request was already made this session.
    *
-   * @param data - The raw backup data
-   * @returns The backup manifest
+   * @param _reason - Which trigger fired (kept for tracing at call sites)
    */
-  static readBackupManifest(data) {
-    return readBackupManifest(data);
-  }
-  recordOperationSequence(operation) {
-    const prev = this.versionVector.get(operation.nodeId) ?? 0;
-    if (operation.sequenceNumber > prev) {
-      this.versionVector.set(operation.nodeId, operation.sequenceNumber);
-    }
-    if (operation.nodeId === this.nodeId) {
-      this.sequenceNumber = Math.max(this.sequenceNumber, operation.sequenceNumber);
-    }
+  requestInBackground(_reason) {
+    if (this.current.persisted || this.current.requested) return;
+    void this.request();
   }
-  async allocateSequenceNumber() {
-    const seq = await allocateNextSequenceNumber(this.adapter, this.nodeId);
-    this.sequenceNumber = seq;
-    this.versionVector.set(this.nodeId, seq);
-    return seq;
-  }
-  /**
-   * Check the stored schema version and run any pending migrations.
-   * Migrations are applied in version order within a transaction.
-   */
-  async runMigrationsIfNeeded() {
-    const storedVersion = await this.getStoredSchemaVersion();
-    const targetVersion = this.schema.version;
-    if (storedVersion >= targetVersion) {
-      if (storedVersion === 0) {
-        await this.adapter.execute(
-          "INSERT OR REPLACE INTO _kora_meta (key, value) VALUES ('schema_version', ?)",
-          [String(targetVersion)]
-        );
-      }
-      return;
-    }
-    const migrations = this.schema.migrations ?? {};
-    for (let v = storedVersion + 1; v <= targetVersion; v++) {
-      const migration = migrations[v];
-      if (!migration) continue;
-      const sqlStatements = migrationStepsToSQL(migration.steps);
-      for (const sql of sqlStatements) {
-        try {
-          await this.adapter.execute(sql);
-        } catch (e) {
-          const msg = e.message || "";
-          if (!msg.includes("duplicate column name")) {
-            throw e;
-          }
-        }
-      }
-      const backfillSteps = migration.steps.filter(
-        (s) => s.type === "backfill"
-      );
-      for (const step of backfillSteps) {
-        await this.runBackfill(step.collection, step.transform);
-      }
-    }
-    await this.adapter.execute(
-      "INSERT OR REPLACE INTO _kora_meta (key, value) VALUES ('schema_version', ?)",
-      [String(targetVersion)]
-    );
+  storage() {
+    return this.storageOverride === void 0 ? defaultStorageManager() : this.storageOverride;
   }
-  /**
-   * Get the stored schema version from _kora_meta. Returns 0 if not set.
-   */
-  async getStoredSchemaVersion() {
-    const rows = await this.adapter.query(
-      "SELECT value FROM _kora_meta WHERE key = 'schema_version'"
-    );
-    return rows[0] ? Number(rows[0].value) : 0;
+  update(next) {
+    this.current = { ...next, requested: this.current.requested };
   }
-  /**
-   * Run a backfill transform on all records in a collection.
-   * Reads all rows, applies the transform, and updates changed fields.
-   */
-  async runBackfill(collection, transform) {
-    const rows = await this.adapter.query(
-      `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) => `${quoteIdent7(f)} = ?`).join(", ");
-        const values = fields.map((f) => {
-          const val = updates[f];
-          if (typeof val === "boolean") return val ? 1 : 0;
-          if (Array.isArray(val) || typeof val === "object" && val !== null) {
-            return JSON.stringify(val);
-          }
-          return val;
-        });
-        values.push(row.id);
-        await tx.execute(`UPDATE ${quoteIdent7(collection)} SET ${setClauses} WHERE id = ?`, values);
-      }
+  emit(state, persisted, message) {
+    this.emitter?.emit({
+      type: "storage:persistence",
+      state,
+      persisted,
+      ...message !== void 0 ? { message } : {}
     });
   }
-  async loadOrGenerateNodeId() {
-    if (this.configNodeId) {
-      if (this.isolation !== "per-tab") {
-        await this.adapter.execute(
-          "INSERT OR REPLACE INTO _kora_meta (key, value) VALUES ('node_id', ?)",
-          [this.configNodeId]
-        );
-      }
-      return this.configNodeId;
-    }
-    if (this.isolation === "per-tab") {
-      return resolvePerTabNodeId(this.dbName);
-    }
-    const rows = await this.adapter.query(
-      "SELECT value FROM _kora_meta WHERE key = 'node_id'"
-    );
-    if (rows[0]) {
-      return rows[0].value;
-    }
-    const newNodeId = generateUUIDv73();
-    await this.adapter.execute("INSERT INTO _kora_meta (key, value) VALUES ('node_id', ?)", [
-      newNodeId
-    ]);
-    return newNodeId;
-  }
-  async loadSequenceNumber() {
-    const rows = await this.adapter.query(
-      "SELECT sequence_number FROM _kora_version_vector WHERE node_id = ?",
-      [this.nodeId]
-    );
-    return rows[0]?.sequence_number ?? 0;
-  }
-  async loadVersionVector() {
-    const rows = await this.adapter.query(
-      "SELECT node_id, sequence_number FROM _kora_version_vector"
-    );
-    const vector = createVersionVector3();
-    for (const row of rows) {
-      vector.set(row.node_id, row.sequence_number);
-    }
-    return vector;
-  }
-  ensureOpen() {
-    if (!this.opened) {
-      throw new StoreNotOpenError();
-    }
-  }
 };
 
 // src/reactivity/query-store.ts
@@ -3174,6 +200,7 @@ var QueryStore = class {
   unsubscribeQuery = null;
   active = false;
   hasEmittedSnapshot = false;
+  error = null;
   queryBuilder;
   constructor(queryBuilder) {
     this.queryBuilder = queryBuilder;
@@ -3206,21 +233,42 @@ var QueryStore = class {
   hasSnapshot = () => {
     return this.hasEmittedSnapshot;
   };
+  /**
+   * The latest query failure, or null. Set when the query (or a re-run after a
+   * write) fails; cleared by the next successful delivery. Listeners are notified
+   * on both transitions, so bindings read it next to `getSnapshot()`.
+   */
+  getError = () => {
+    return this.error;
+  };
   /** Tear down listeners and the underlying query subscription. */
   destroy() {
     this.stopSubscription();
     this.listeners.clear();
     this.snapshot = EMPTY_ARRAY;
     this.hasEmittedSnapshot = false;
+    this.error = null;
   }
   startSubscription() {
     this.active = true;
-    this.unsubscribeQuery = this.queryBuilder.subscribe((results) => {
-      if (!this.active) return;
-      this.hasEmittedSnapshot = true;
-      this.snapshot = Object.freeze([...results]);
-      this.notifyListeners();
-    });
+    this.unsubscribeQuery = this.queryBuilder.subscribe(
+      (results) => {
+        if (!this.active) return;
+        this.hasEmittedSnapshot = true;
+        this.error = null;
+        this.snapshot = Object.freeze([...results]);
+        this.notifyListeners();
+      },
+      {
+        // STORE-12: the failure reaches bindings as error state; the last
+        // snapshot stays readable and the next success clears the error.
+        onError: (failure) => {
+          if (!this.active) return;
+          this.error = failure.error;
+          this.notifyListeners();
+        }
+      }
+    );
   }
   stopSubscription() {
     this.active = false;
@@ -3291,7 +339,7 @@ var QueryStoreCache = class {
     return this.entries.size;
   }
   getKey(queryBuilder) {
-    return `${this.scopeKey}:${JSON.stringify(queryBuilder.getDescriptor())}`;
+    return `${this.scopeKey}:${queryKey(queryBuilder.getDescriptor())}`;
   }
 };
 var sharedCache = null;
@@ -3308,7 +356,6 @@ var LOAD_ORIGIN = "kora-load";
 var REMOTE_ORIGIN = "kora-remote";
 var DOC_CHANNEL_ORIGIN = "kora-doc-channel";
 var TEXT_KEY = "content";
-var COMPACT_AFTER_DELTAS = 20;
 var PERSIST_DEBOUNCE_MS = 400;
 function createRichTextController(options) {
   const {
@@ -3330,16 +377,19 @@ function createRichTextController(options) {
   let canUndo = false;
   let canRedo = false;
   let cursors = [];
+  let editGeneration = 0;
+  let savedGeneration = 0;
+  let saving = null;
+  let saveAgain = false;
   const listeners = /* @__PURE__ */ new Set();
   let snapshot = {
     ready: false,
     error: null,
     canUndo: false,
     canRedo: false,
-    cursors: []
+    cursors: [],
+    hasUnsavedChanges: false
   };
-  const baseUpdateRef = { current: null };
-  const pendingDeltasRef = { current: [] };
   const docChannelActiveRef = { current: false };
   let persistTimer = null;
   let recordUnsubscribe = null;
@@ -3351,7 +401,8 @@ function createRichTextController(options) {
       error,
       canUndo,
       canRedo,
-      cursors: [...cursors]
+      cursors: [...cursors],
+      hasUnsavedChanges: editGeneration > savedGeneration
     };
   };
   const notify = () => {
@@ -3422,26 +473,38 @@ function createRichTextController(options) {
       return;
     }
     Y.applyUpdate(doc, encoded, REMOTE_ORIGIN);
-    baseUpdateRef.current = encoded;
-    pendingDeltasRef.current = [];
     syncHistoryState();
   };
-  const flushPersist = async () => {
-    const snapshot2 = composeRichtextSnapshot(baseUpdateRef.current, pendingDeltasRef.current);
-    if (pendingDeltasRef.current.length >= COMPACT_AFTER_DELTAS) {
-      baseUpdateRef.current = snapshot2;
-      pendingDeltasRef.current = [];
-    }
+  const persistOnce = async () => {
+    const generation = editGeneration;
+    const state = Y.encodeStateAsUpdate(doc);
     try {
       await collection.update(recordId, {
-        [fieldName]: snapshot2
+        [fieldName]: state
       });
+      if (generation > savedGeneration) savedGeneration = generation;
+      error = null;
     } catch (cause) {
-      if (!disposed) {
-        error = cause instanceof Error ? cause : new Error(String(cause));
-        notify();
-      }
+      error = cause instanceof Error ? cause : new Error(String(cause));
     }
+    if (!disposed) notify();
+  };
+  const flushPersist = () => {
+    if (saving) {
+      saveAgain = true;
+      return saving;
+    }
+    const run = (async () => {
+      do {
+        saveAgain = false;
+        await persistOnce();
+      } while (saveAgain);
+    })();
+    saving = run;
+    void run.finally(() => {
+      if (saving === run) saving = null;
+    });
+    return run;
   };
   const schedulePersist = () => {
     if (persistTimer) {
@@ -3457,7 +520,7 @@ function createRichTextController(options) {
     if (origin === LOAD_ORIGIN || origin === REMOTE_ORIGIN || origin === DOC_CHANNEL_ORIGIN) {
       return;
     }
-    pendingDeltasRef.current.push(update);
+    editGeneration += 1;
     if (docChannelActiveRef.current && syncEngine) {
       syncEngine.getRichtextDocChannel?.().send(collectionName, recordId, fieldName, update);
       schedulePersist();
@@ -3541,8 +604,6 @@ function createRichTextController(options) {
         target.delete(0, target.length);
       }, LOAD_ORIGIN);
       const encoded = encodeRichtextInput(record?.[fieldName]);
-      baseUpdateRef.current = encoded;
-      pendingDeltasRef.current = [];
       if (encoded) {
         Y.applyUpdate(doc, encoded, LOAD_ORIGIN);
       }
@@ -3585,6 +646,16 @@ function createRichTextController(options) {
     setUser(nextUser) {
       user = nextUser;
     },
+    retrySave() {
+      if (persistTimer) {
+        clearTimeout(persistTimer);
+        persistTimer = null;
+      }
+      return flushPersist();
+    },
+    getUnsavedState() {
+      return editGeneration > savedGeneration ? Y.encodeStateAsUpdate(doc) : null;
+    },
     destroy() {
       if (disposed) {
         return;
@@ -3594,14 +665,15 @@ function createRichTextController(options) {
         clearTimeout(persistTimer);
         persistTimer = null;
       }
+      if (editGeneration > savedGeneration) {
+        void flushPersist();
+      }
       doc.off("update", onDocUpdate);
       recordUnsubscribe?.();
       docChannelUnsubscribe?.();
       awarenessUnsubscribe?.();
       clearCursor();
       undoManager.destroy();
-      baseUpdateRef.current = null;
-      pendingDeltasRef.current = [];
       docChannelActiveRef.current = false;
       listeners.clear();
     }
@@ -3622,16 +694,6 @@ function encodeRichtextInput(value) {
     throw new Error("Richtext record value must be a string, Uint8Array, ArrayBuffer, or null.");
   }
 }
-function composeRichtextSnapshot(base, deltas) {
-  const mergedDoc = new Y.Doc();
-  if (base) {
-    Y.applyUpdate(mergedDoc, base);
-  }
-  for (const delta of deltas) {
-    Y.applyUpdate(mergedDoc, delta);
-  }
-  return Y.encodeStateAsUpdate(mergedDoc);
-}
 function updatesEqual(left, right) {
   if (left.length !== right.length) {
     return false;
@@ -3711,12 +773,6 @@ function isNotFoundError(error) {
 }
 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) {
@@ -4078,10 +1134,19 @@ async function collectBlobGarbage(store, liveRefs, options = {}) {
 }
 
 // src/blob/blob-chunk-transport.ts
-import { generateUUIDv7 as generateUUIDv74 } from "@korajs/core";
+import { generateUUIDv7 } from "@korajs/core";
 function createRemoteChunkProvider(port, options = {}) {
   const timeoutMs = options.timeoutMs ?? 3e4;
+  const maxThrottleWaitMs = options.maxThrottleWaitMs ?? 10 * 6e4;
+  const minDelayMs = options.minThrottleDelayMs ?? 250;
+  const maxDelayMs = options.maxThrottleDelayMs ?? 3e4;
   const pending = /* @__PURE__ */ new Map();
+  const armTimeout = (requestId, hash) => setTimeout(() => {
+    const entry = pending.get(requestId);
+    if (!entry) return;
+    pending.delete(requestId);
+    entry.reject(new Error(`Blob chunk request for ${hash} timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
   port.onMessage((message) => {
     if (message.type !== "blob-chunk-response") {
       return;
@@ -4090,20 +1155,43 @@ function createRemoteChunkProvider(port, options = {}) {
     if (!entry) {
       return;
     }
-    pending.delete(message.requestId);
     clearTimeout(entry.timer);
+    if (message.throttled === true) {
+      entry.throttledCount += 1;
+      const backoff = Math.min(maxDelayMs, minDelayMs * 2 ** (entry.throttledCount - 1));
+      const delay = Math.min(maxDelayMs, Math.max(minDelayMs, message.retryAfterMs ?? backoff));
+      if (Date.now() + delay - entry.startedAtMs > maxThrottleWaitMs) {
+        pending.delete(message.requestId);
+        entry.reject(
+          new Error(
+            `Blob chunk request for ${entry.hash} was throttled for longer than ${maxThrottleWaitMs}ms`
+          )
+        );
+        return;
+      }
+      entry.timer = setTimeout(() => {
+        if (pending.get(message.requestId) !== entry) return;
+        entry.timer = armTimeout(message.requestId, entry.hash);
+        port.send({ type: "blob-chunk-request", requestId: message.requestId, hash: entry.hash });
+      }, delay);
+      return;
+    }
+    pending.delete(message.requestId);
     entry.resolve(message.bytes);
   });
   return {
     pendingCount: () => pending.size,
     getChunk(hash) {
-      const requestId = generateUUIDv74();
+      const requestId = generateUUIDv7();
       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 });
+        pending.set(requestId, {
+          hash,
+          resolve,
+          reject,
+          timer: armTimeout(requestId, hash),
+          startedAtMs: Date.now(),
+          throttledCount: 0
+        });
         port.send({ type: "blob-chunk-request", requestId, hash });
       });
     }
@@ -4155,14 +1243,20 @@ function createChunkPortPair() {
 }
 export {
   AdapterError,
+  BACKUP_VERSION,
+  BackupFormatError,
   BlobIntegrityError,
+  BridgeTerminatedError,
   COMPACTION_BASELINE_META_KEY,
   Collection,
   DEFAULT_CHUNK_SIZE,
   InvalidStateTransitionError,
   LAST_ACKED_SERVER_VECTOR_META_KEY,
+  LOG_QUARANTINE_TABLE,
+  LeaderUnresponsiveError,
   MemoryBlobStore,
   NoLeaderError,
+  NodeOwnedByAnotherUserError,
   OpfsBlobStore,
   OptimisticLockError,
   PersistenceError,
@@ -4171,12 +1265,21 @@ export {
   QueryStore,
   QueryStoreCache,
   RecordNotFoundError,
+  RequestAbortedError,
+  SchemaVersionAheadError,
   SequenceManager,
+  StorageBackendMismatchError,
+  StorageDurabilityError,
+  StorageInUseError,
+  StoragePersistence,
   Store,
   StoreNotOpenError,
   SubscriptionBloomFilter,
   SubscriptionManager,
   TransactionContext,
+  UnsyncedDataError,
+  VIRTUAL_TIMESTAMP_FIELDS,
+  VIRTUAL_TIMESTAMP_FIELD_NAMES,
   WorkerInitError,
   WorkerTimeoutError,
   asRichTextSyncEngine,
@@ -4186,6 +1289,7 @@ export {
   collectOperationsAheadOfServer,
   compactOperationLog,
   computeAckCompactionWatermark,
+  convertBackupV1,
   createChunkPortPair,
   createMemoryServerBlobStore,
   createOpfsBlobDirectory,
@@ -4201,11 +1305,14 @@ export {
   fetchBlobManifest,
   getSharedQueryStoreCache,
   mergeVersionVectors,
+  mergeYjsUpdates,
+  normalizeWhere,
   parseBlobManifest,
   persistedAuditTraceFromEvent,
   pluralize,
   prepareBlobForSend,
   putBlobForTransfer,
+  queryKey,
   readAuditExportManifest,
   readBackupManifest,
   reassembleBlob,