@korajs/store 0.3.2 → 0.5.0

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,237 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AdapterError: () => AdapterError,
-  Collection: () => Collection,
-  PersistenceError: () => PersistenceError,
-  QueryBuilder: () => QueryBuilder,
-  QueryError: () => QueryError,
-  RecordNotFoundError: () => RecordNotFoundError,
-  Store: () => Store,
-  StoreNotOpenError: () => StoreNotOpenError,
-  SubscriptionManager: () => SubscriptionManager,
-  WorkerInitError: () => WorkerInitError,
-  WorkerTimeoutError: () => WorkerTimeoutError,
-  decodeRichtext: () => decodeRichtext,
-  encodeRichtext: () => encodeRichtext,
-  pluralize: () => pluralize,
-  richtextToPlainText: () => richtextToPlainText,
-  singularize: () => singularize
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/errors.ts
-var import_core = require("@korajs/core");
-var QueryError = class extends import_core.KoraError {
-  constructor(message, context) {
-    super(message, "QUERY_ERROR", context);
-    this.name = "QueryError";
-  }
-};
-var RecordNotFoundError = class extends import_core.KoraError {
-  constructor(collection, recordId) {
-    super(`Record "${recordId}" not found in collection "${collection}"`, "RECORD_NOT_FOUND", {
-      collection,
-      recordId
-    });
-    this.name = "RecordNotFoundError";
-  }
-};
-var AdapterError = class extends import_core.KoraError {
-  constructor(message, context) {
-    super(message, "ADAPTER_ERROR", context);
-    this.name = "AdapterError";
-  }
-};
-var StoreNotOpenError = class extends import_core.KoraError {
-  constructor() {
-    super("Store is not open. Call store.open() before performing operations.", "STORE_NOT_OPEN");
-    this.name = "StoreNotOpenError";
-  }
-};
-var WorkerInitError = class extends import_core.KoraError {
-  constructor(message, context) {
-    super(`Worker initialization failed: ${message}`, "WORKER_INIT_ERROR", context);
-    this.name = "WorkerInitError";
-  }
-};
-var WorkerTimeoutError = class extends import_core.KoraError {
-  constructor(operation, timeoutMs) {
-    super(
-      `Worker did not respond within ${timeoutMs}ms for operation "${operation}"`,
-      "WORKER_TIMEOUT",
-      { operation, timeoutMs }
-    );
-    this.name = "WorkerTimeoutError";
-  }
-};
-var PersistenceError = class extends import_core.KoraError {
-  constructor(message, context) {
-    super(`Persistence error: ${message}`, "PERSISTENCE_ERROR", context);
-    this.name = "PersistenceError";
-  }
-};
-
-// src/store/store.ts
-var import_core4 = require("@korajs/core");
-
-// src/collection/collection.ts
-var import_core3 = require("@korajs/core");
-
-// src/query/sql-builder.ts
-function buildSelectQuery(descriptor, fields) {
-  const params = [];
-  const parts = [`SELECT * FROM ${descriptor.collection}`];
-  const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
-  const deletedFilter = "_deleted = 0";
-  if (whereClause) {
-    parts.push(`WHERE ${deletedFilter} AND ${whereClause}`);
-  } else {
-    parts.push(`WHERE ${deletedFilter}`);
-  }
-  if (descriptor.orderBy.length > 0) {
-    const orderParts = descriptor.orderBy.map((o) => {
-      validateFieldName(o.field, fields);
-      return `${o.field} ${o.direction.toUpperCase()}`;
-    });
-    parts.push(`ORDER BY ${orderParts.join(", ")}`);
-  }
-  if (descriptor.limit !== void 0) {
-    parts.push(`LIMIT ${descriptor.limit}`);
-  }
-  if (descriptor.offset !== void 0) {
-    parts.push(`OFFSET ${descriptor.offset}`);
-  }
-  return { sql: parts.join(" "), params };
-}
-function buildCountQuery(descriptor, fields) {
-  const params = [];
-  const parts = [`SELECT COUNT(*) as count FROM ${descriptor.collection}`];
-  const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
-  const deletedFilter = "_deleted = 0";
-  if (whereClause) {
-    parts.push(`WHERE ${deletedFilter} AND ${whereClause}`);
-  } else {
-    parts.push(`WHERE ${deletedFilter}`);
-  }
-  return { sql: parts.join(" "), params };
-}
-function buildInsertQuery(collection, record) {
-  const columns = Object.keys(record);
-  const placeholders = columns.map(() => "?");
-  const params = Object.values(record);
-  const sql = `INSERT INTO ${collection} (${columns.join(", ")}) VALUES (${placeholders.join(", ")})`;
-  return { sql, params };
-}
-function buildUpdateQuery(collection, id, changes) {
-  const setClauses = Object.keys(changes).map((col) => `${col} = ?`);
-  const params = [...Object.values(changes), id];
-  const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ?`;
-  return { sql, params };
-}
-function buildSoftDeleteQuery(collection, id, updatedAt) {
-  return {
-    sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ? WHERE id = ?`,
-    params: [updatedAt, id]
-  };
-}
-var VALID_OPERATORS = /* @__PURE__ */ new Set(["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in"]);
-function buildWhereClauseParts(where, fields, params) {
-  const conditions = [];
-  for (const [fieldName, value] of Object.entries(where)) {
-    validateFieldName(fieldName, fields);
-    const descriptor = fields[fieldName];
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      const ops = value;
-      for (const [op, opValue] of Object.entries(ops)) {
-        if (!VALID_OPERATORS.has(op)) {
-          throw new QueryError(`Unknown operator "${op}" on field "${fieldName}"`, {
-            field: fieldName,
-            operator: op,
-            validOperators: [...VALID_OPERATORS]
-          });
-        }
-        conditions.push(buildOperatorCondition(fieldName, op, opValue, descriptor, params));
-      }
-    } else {
-      conditions.push(buildOperatorCondition(fieldName, "$eq", value, descriptor, params));
-    }
-  }
-  if (conditions.length === 0) return null;
-  return conditions.join(" AND ");
-}
-function buildOperatorCondition(fieldName, operator, value, descriptor, params) {
-  const sqlValue = descriptor?.kind === "boolean" && typeof value === "boolean" ? value ? 1 : 0 : value;
-  switch (operator) {
-    case "$eq":
-      if (sqlValue === null) {
-        return `${fieldName} IS NULL`;
-      }
-      params.push(sqlValue);
-      return `${fieldName} = ?`;
-    case "$ne":
-      if (sqlValue === null) {
-        return `${fieldName} IS NOT NULL`;
-      }
-      params.push(sqlValue);
-      return `${fieldName} != ?`;
-    case "$gt":
-      params.push(sqlValue);
-      return `${fieldName} > ?`;
-    case "$gte":
-      params.push(sqlValue);
-      return `${fieldName} >= ?`;
-    case "$lt":
-      params.push(sqlValue);
-      return `${fieldName} < ?`;
-    case "$lte":
-      params.push(sqlValue);
-      return `${fieldName} <= ?`;
-    case "$in": {
-      if (!Array.isArray(sqlValue)) {
-        throw new QueryError(`$in operator requires an array value for field "${fieldName}"`, {
-          field: fieldName,
-          received: typeof sqlValue
-        });
-      }
-      const placeholders = sqlValue.map(() => "?");
-      for (const item of sqlValue) {
-        params.push(
-          descriptor?.kind === "boolean" && typeof item === "boolean" ? item ? 1 : 0 : item
-        );
-      }
-      return `${fieldName} IN (${placeholders.join(", ")})`;
-    }
-    default:
-      throw new QueryError(`Unknown operator "${operator}"`, { operator });
-  }
-}
-function validateFieldName(fieldName, fields) {
-  const allowedFields = /* @__PURE__ */ new Set([
-    ...Object.keys(fields),
-    "id",
-    "createdAt",
-    "updatedAt",
-    "_created_at",
-    "_updated_at"
-  ]);
-  if (!allowedFields.has(fieldName)) {
-    throw new QueryError(
-      `Unknown field "${fieldName}" in query. Available fields: ${[...allowedFields].join(", ")}`,
-      { field: fieldName }
-    );
-  }
-}
-
-// src/serialization/serializer.ts
-var import_core2 = require("@korajs/core");
-
 // src/serialization/richtext-serializer.ts
-var Y = __toESM(require("yjs"), 1);
-var TEXT_KEY = "content";
 function encodeRichtext(value) {
   if (value === null || value === void 0) {
     return null;
@@ -288,7 +61,9 @@ function decodeRichtext(value) {
   if (value instanceof ArrayBuffer) {
     return new Uint8Array(value);
   }
-  throw new Error("Richtext storage value must be Uint8Array, ArrayBuffer, Buffer, null, or undefined.");
+  throw new Error(
+    "Richtext storage value must be Uint8Array, ArrayBuffer, Buffer, null, or undefined."
+  );
 }
 function richtextToPlainText(value) {
   const encoded = encodeRichtext(value);
@@ -297,6 +72,21 @@ function richtextToPlainText(value) {
   Y.applyUpdate(doc, encoded);
   return doc.getText(TEXT_KEY).toString();
 }
+function richtextStatesEqual(a, b) {
+  try {
+    return richtextToPlainText(a) === richtextToPlainText(b);
+  } catch {
+    return false;
+  }
+}
+var Y, TEXT_KEY;
+var init_richtext_serializer = __esm({
+  "src/serialization/richtext-serializer.ts"() {
+    "use strict";
+    Y = __toESM(require("yjs"), 1);
+    TEXT_KEY = "content";
+  }
+});
 
 // src/serialization/serializer.ts
 function serializeRecord(data, fields) {
@@ -328,20 +118,60 @@ function deserializeRecord(row, fields) {
   return result;
 }
 function serializeOperation(op) {
+  const hasMetadata = op.transactionId !== void 0 || op.mutationName !== void 0;
+  let dataPayload = null;
+  if (op.data) {
+    dataPayload = { ...op.data };
+    if (op.atomicOps !== void 0 && Object.keys(op.atomicOps).length > 0) {
+      dataPayload[ATOMIC_OPS_KEY] = op.atomicOps;
+    }
+    if (op.transactionId !== void 0) {
+      dataPayload[TX_ID_KEY] = op.transactionId;
+    }
+    if (op.mutationName !== void 0) {
+      dataPayload[MUTATION_NAME_KEY] = op.mutationName;
+    }
+  } else if (hasMetadata) {
+    dataPayload = {};
+    if (op.transactionId !== void 0) {
+      dataPayload[TX_ID_KEY] = op.transactionId;
+    }
+    if (op.mutationName !== void 0) {
+      dataPayload[MUTATION_NAME_KEY] = op.mutationName;
+    }
+  }
   return {
     id: op.id,
     node_id: op.nodeId,
     type: op.type,
     record_id: op.recordId,
-    data: op.data ? JSON.stringify(op.data) : null,
+    data: dataPayload ? JSON.stringify(dataPayload) : null,
     previous_data: op.previousData ? JSON.stringify(op.previousData) : null,
-    timestamp: import_core2.HybridLogicalClock.serialize(op.timestamp),
+    timestamp: import_core4.HybridLogicalClock.serialize(op.timestamp),
     sequence_number: op.sequenceNumber,
     causal_deps: JSON.stringify(op.causalDeps),
     schema_version: op.schemaVersion
   };
 }
 function deserializeOperation(row) {
+  let data = null;
+  let atomicOps;
+  let transactionId;
+  let mutationName;
+  if (row.data) {
+    const parsed = JSON.parse(row.data);
+    if (ATOMIC_OPS_KEY in parsed) {
+      atomicOps = parsed[ATOMIC_OPS_KEY];
+    }
+    if (TX_ID_KEY in parsed) {
+      transactionId = parsed[TX_ID_KEY];
+    }
+    if (MUTATION_NAME_KEY in parsed) {
+      mutationName = parsed[MUTATION_NAME_KEY];
+    }
+    const { [ATOMIC_OPS_KEY]: _a, [TX_ID_KEY]: _t, [MUTATION_NAME_KEY]: _m, ...rest } = parsed;
+    data = Object.keys(rest).length > 0 ? rest : null;
+  }
   return {
     id: row.id,
     nodeId: row.node_id,
@@ -349,12 +179,15 @@ function deserializeOperation(row) {
     collection: "",
     // Collection name is derived from the table name by the caller
     recordId: row.record_id,
-    data: row.data ? JSON.parse(row.data) : null,
+    data,
     previousData: row.previous_data ? JSON.parse(row.previous_data) : null,
-    timestamp: import_core2.HybridLogicalClock.deserialize(row.timestamp),
+    timestamp: import_core4.HybridLogicalClock.deserialize(row.timestamp),
     sequenceNumber: row.sequence_number,
     causalDeps: JSON.parse(row.causal_deps),
-    schemaVersion: row.schema_version
+    schemaVersion: row.schema_version,
+    ...atomicOps !== void 0 ? { atomicOps } : {},
+    ...transactionId !== void 0 ? { transactionId } : {},
+    ...mutationName !== void 0 ? { mutationName } : {}
   };
 }
 function deserializeOperationWithCollection(row, collection) {
@@ -391,219 +224,1571 @@ function deserializeValue(value, descriptor) {
       return value;
   }
 }
+var import_core4, ATOMIC_OPS_KEY, TX_ID_KEY, MUTATION_NAME_KEY;
+var init_serializer = __esm({
+  "src/serialization/serializer.ts"() {
+    "use strict";
+    import_core4 = require("@korajs/core");
+    init_richtext_serializer();
+    ATOMIC_OPS_KEY = "__kora_atomic_ops__";
+    TX_ID_KEY = "__kora_tx_id__";
+    MUTATION_NAME_KEY = "__kora_mutation__";
+  }
+});
 
-// src/collection/collection.ts
-var Collection = class {
-  constructor(name, definition, schema, adapter, clock, nodeId, getSequenceNumber, onMutation) {
-    this.name = name;
-    this.definition = definition;
-    this.schema = schema;
-    this.adapter = adapter;
-    this.clock = clock;
-    this.nodeId = nodeId;
-    this.getSequenceNumber = getSequenceNumber;
-    this.onMutation = onMutation;
+// src/backup/backup.ts
+var backup_exports = {};
+__export(backup_exports, {
+  exportBackup: () => exportBackup,
+  readBackupManifest: () => readBackupManifest,
+  restoreBackup: () => restoreBackup,
+  verifyBackupChecksum: () => verifyBackupChecksum
+});
+function encodeSection(name, content) {
+  const nameBytes = new TextEncoder().encode(name);
+  const header = new Uint8Array(8);
+  const dv = new DataView(header.buffer);
+  dv.setUint32(0, nameBytes.length, true);
+  dv.setUint32(4, content.length, true);
+  const result = new Uint8Array(header.length + nameBytes.length + content.length);
+  result.set(header, 0);
+  result.set(nameBytes, 8);
+  result.set(content, 8 + nameBytes.length);
+  return result;
+}
+function encodeJsonSection(name, data) {
+  const json = JSON.stringify(data);
+  return encodeSection(name, new TextEncoder().encode(json));
+}
+function readUint32(view, offset) {
+  return view.getUint32(offset, true);
+}
+function parseSections(data) {
+  const sections = [];
+  const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let offset = 0;
+  while (offset + 8 <= data.byteLength) {
+    const nameLen = readUint32(dv, offset);
+    const contentLen = readUint32(dv, offset + 4);
+    offset += 8;
+    if (offset + nameLen + contentLen > data.byteLength) break;
+    const name = new TextDecoder().decode(data.slice(offset, offset + nameLen));
+    offset += nameLen;
+    const content = data.slice(offset, offset + contentLen);
+    offset += contentLen;
+    sections.push({ name, content });
   }
-  name;
-  definition;
-  schema;
-  adapter;
-  clock;
-  nodeId;
-  getSequenceNumber;
-  onMutation;
-  /**
-   * Insert a new record into the collection.
-   * Generates a UUID v7 for the id, validates data, and persists atomically.
-   *
-   * @param data - The record data (auto fields and defaults are applied automatically)
-   * @returns The inserted record with id, createdAt, updatedAt
-   */
-  async insert(data) {
-    const validated = (0, import_core3.validateRecord)(this.name, this.definition, data, "insert");
-    const recordId = (0, import_core3.generateUUIDv7)();
-    const now = Date.now();
-    for (const [fieldName, descriptor] of Object.entries(this.definition.fields)) {
-      if (descriptor.auto && descriptor.kind === "timestamp") {
-        validated[fieldName] = now;
+  return sections;
+}
+function findSection(sections, name) {
+  for (const s of sections) {
+    if (s.name === name) return s.content;
+  }
+  return null;
+}
+function parseJsonSection(sections, name) {
+  const content = findSection(sections, name);
+  if (!content) return null;
+  return JSON.parse(new TextDecoder().decode(content));
+}
+async function exportBackup(adapter, schema, nodeId, schemaVersion, options) {
+  const onProgress = options?.onProgress ?? (() => {
+  });
+  const includeRecords = options?.includeRecords ?? true;
+  const collectionFilter = options?.collections;
+  const collections = collectionFilter ? Object.keys(schema.collections).filter((c) => collectionFilter.includes(c)) : Object.keys(schema.collections);
+  onProgress({ phase: "reading", progress: 0, message: "Reading version vector" });
+  const versionVector = await readVersionVector(adapter);
+  onProgress({ phase: "reading", progress: 0.1, message: "Reading metadata" });
+  const meta = await readMeta(adapter);
+  onProgress({ phase: "reading", progress: 0.2, message: "Reading operations" });
+  const operations = await readAllOperations(adapter, schema);
+  onProgress({ phase: "reading", progress: 0.5, message: "Reading records" });
+  const sections = [];
+  let allContentForChecksum = new Uint8Array(0);
+  const addSection = (name, data) => {
+    sections.push(data);
+    const newLen = allContentForChecksum.length + data.length;
+    const combined = new Uint8Array(newLen);
+    combined.set(allContentForChecksum, 0);
+    combined.set(data, allContentForChecksum.length);
+    allContentForChecksum = combined;
+  };
+  const vvObj = {};
+  for (const [nid, seq] of versionVector) {
+    vvObj[nid] = seq;
+  }
+  addSection("version_vector", encodeJsonSection("version_vector", vvObj));
+  const metaObj = {};
+  for (const row of meta) {
+    metaObj[row.key] = row.value;
+  }
+  addSection("meta", encodeJsonSection("meta", metaObj));
+  const opLines = `${operations.map((op) => JSON.stringify(op)).join("\n")}
+`;
+  addSection("operations", encodeSection("operations", new TextEncoder().encode(opLines)));
+  let totalRecords = 0;
+  if (includeRecords) {
+    for (const col of collections) {
+      const records = await readCollectionRecords(adapter, col);
+      if (records.length > 0) {
+        const lines = `${records.map((r) => JSON.stringify(r)).join("\n")}
+`;
+        const sectionName = `records:${col}`;
+        addSection(sectionName, encodeSection(sectionName, new TextEncoder().encode(lines)));
+        totalRecords += records.length;
+      }
+    }
+  }
+  onProgress({ phase: "reading", progress: 0.9, message: "Computing checksum" });
+  const checksumHex = await computeSha256(allContentForChecksum);
+  onProgress({ phase: "writing", progress: 1, message: "Finalizing" });
+  const manifest = {
+    version: BACKUP_VERSION,
+    createdAt: Date.now(),
+    nodeId,
+    schemaVersion,
+    operationCount: operations.length,
+    collections,
+    includesRecords: includeRecords,
+    checksum: checksumHex
+  };
+  const header = new Uint8Array(0);
+  const manifestSection = encodeJsonSection("manifest", manifest);
+  const checksumSection = encodeSection("checksum", new TextEncoder().encode(checksumHex));
+  const totalLen = manifestSection.length + allContentForChecksum.length + checksumSection.length;
+  const result = new Uint8Array(totalLen);
+  let pos = 0;
+  result.set(manifestSection, pos);
+  pos += manifestSection.length;
+  result.set(allContentForChecksum, pos);
+  pos += allContentForChecksum.length;
+  result.set(checksumSection, pos);
+  return result;
+}
+function readBackupManifest(data) {
+  const sections = parseSections(data);
+  const manifest = parseJsonSection(sections, "manifest");
+  if (!manifest) {
+    throw new Error("Invalid backup: manifest section not found");
+  }
+  return manifest;
+}
+async function verifyBackupChecksum(data) {
+  const sections = parseSections(data);
+  const manifest = parseJsonSection(sections, "manifest");
+  if (!manifest) return false;
+  const storedChecksum = manifest.checksum;
+  if (!storedChecksum) return false;
+  const manifestSection = findSection(sections, "manifest");
+  if (!manifestSection) return false;
+  const checksumSection = findSection(sections, "checksum");
+  const checksumBytes = checksumSection ? new TextEncoder().encode(manifest.checksum) : new Uint8Array(0);
+  const contentSections = sections.filter((s) => s.name !== "manifest" && s.name !== "checksum");
+  let contentForHash = new Uint8Array(0);
+  for (const section of contentSections) {
+    const sectionBytes = encodeSection(section.name, section.content);
+    const newLen = contentForHash.length + sectionBytes.length;
+    const combined = new Uint8Array(newLen);
+    combined.set(contentForHash, 0);
+    combined.set(sectionBytes, contentForHash.length);
+    contentForHash = combined;
+  }
+  const computed = await computeSha256(contentForHash);
+  return computed === storedChecksum;
+}
+async function restoreBackup(adapter, schema, data, options) {
+  const startTime = Date.now();
+  const onProgress = options?.onProgress ?? (() => {
+  });
+  const collectionFilter = options?.collections;
+  onProgress({ phase: "verifying", progress: 0, message: "Parsing backup" });
+  const sections = parseSections(data);
+  const manifest = parseJsonSection(sections, "manifest");
+  if (!manifest) {
+    return {
+      operationsRestored: 0,
+      recordsRestored: 0,
+      success: false,
+      error: "Invalid backup: manifest section not found",
+      duration: Date.now() - startTime
+    };
+  }
+  if (manifest.version !== BACKUP_VERSION) {
+    return {
+      operationsRestored: 0,
+      recordsRestored: 0,
+      success: false,
+      error: `Unsupported backup version: ${manifest.version}`,
+      duration: Date.now() - startTime
+    };
+  }
+  onProgress({ phase: "verifying", progress: 0.2, message: "Verifying checksum" });
+  const valid = await verifyBackupChecksum(data);
+  if (!valid) {
+    return {
+      operationsRestored: 0,
+      recordsRestored: 0,
+      success: false,
+      error: "Backup checksum mismatch: data may be corrupted",
+      duration: Date.now() - startTime
+    };
+  }
+  onProgress({ phase: "restoring", progress: 0.3, message: "Loading operations" });
+  const opsContent = findSection(sections, "operations");
+  let operations = [];
+  if (opsContent) {
+    const text = new TextDecoder().decode(opsContent);
+    const lines = text.trim().split("\n").filter((l) => l.length > 0);
+    operations = lines.map((line) => JSON.parse(line));
+  }
+  if (collectionFilter) {
+    operations = operations.filter((op) => collectionFilter.includes(op.collection));
+  }
+  const vvData = parseJsonSection(sections, "version_vector");
+  const metaData = parseJsonSection(sections, "meta");
+  onProgress({ phase: "restoring", progress: 0.4, message: "Applying operations" });
+  if (options?.merge) {
+    await adapter.transaction(async (tx) => {
+      if (vvData) {
+        for (const [nid, seq] of Object.entries(vvData)) {
+          await tx.execute(
+            "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
+            [nid, seq]
+          );
+        }
+      }
+      if (metaData) {
+        for (const [key, value] of Object.entries(metaData)) {
+          await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+            key,
+            value
+          ]);
+        }
+      }
+      for (const op of operations) {
+        const collection = op.collection;
+        const opRow = {
+          id: op.id,
+          node_id: op.nodeId,
+          type: op.type,
+          record_id: op.recordId,
+          data: op.data !== null ? JSON.stringify(op.data) : null,
+          previous_data: op.previousData !== null ? JSON.stringify(op.previousData) : null,
+          timestamp: JSON.stringify(op.timestamp),
+          sequence_number: op.sequenceNumber,
+          causal_deps: JSON.stringify(op.causalDeps),
+          schema_version: op.schemaVersion
+        };
+        await tx.execute(
+          `INSERT OR IGNORE INTO _kora_ops_${collection} (id, node_id, type, record_id, data, previous_data, timestamp, sequence_number, causal_deps, schema_version) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            opRow.id,
+            opRow.node_id,
+            opRow.type,
+            opRow.record_id,
+            opRow.data,
+            opRow.previous_data,
+            opRow.timestamp,
+            opRow.sequence_number,
+            opRow.causal_deps,
+            opRow.schema_version
+          ]
+        );
+      }
+    });
+  } else {
+    await adapter.transaction(async (tx) => {
+      for (const collection of Object.keys(schema.collections)) {
+        await tx.execute(`DELETE FROM _kora_ops_${collection}`);
+        await tx.execute(`DELETE FROM ${collection}`);
+      }
+      await tx.execute("DELETE FROM _kora_version_vector");
+      await tx.execute("DELETE FROM _kora_meta");
+      if (vvData) {
+        for (const [nid, seq] of Object.entries(vvData)) {
+          await tx.execute(
+            "INSERT INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
+            [nid, seq]
+          );
+        }
+      }
+      if (metaData) {
+        for (const [key, value] of Object.entries(metaData)) {
+          await tx.execute("INSERT INTO _kora_meta (key, value) VALUES (?, ?)", [key, value]);
+        }
+      }
+      for (const op of operations) {
+        const collection = op.collection;
+        await tx.execute(
+          `INSERT INTO _kora_ops_${collection} (id, node_id, type, record_id, data, previous_data, timestamp, sequence_number, causal_deps, schema_version) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            op.id,
+            op.nodeId,
+            op.type,
+            op.recordId,
+            op.data !== null ? JSON.stringify(op.data) : null,
+            op.previousData !== null ? JSON.stringify(op.previousData) : null,
+            JSON.stringify(op.timestamp),
+            op.sequenceNumber,
+            JSON.stringify(op.causalDeps),
+            op.schemaVersion
+          ]
+        );
+      }
+    });
+  }
+  onProgress({ phase: "restoring", progress: 0.8, message: "Restoring records" });
+  let recordsRestored = 0;
+  if (manifest.includesRecords) {
+    for (const col of manifest.collections) {
+      if (collectionFilter && !collectionFilter.includes(col)) continue;
+      const sectionContent = findSection(sections, `records:${col}`);
+      if (!sectionContent) continue;
+      const text = new TextDecoder().decode(sectionContent);
+      const lines = text.trim().split("\n").filter((l) => l.length > 0);
+      const records = lines.map((line) => JSON.parse(line));
+      if (records.length === 0) continue;
+      await adapter.transaction(async (tx) => {
+        for (const record of records) {
+          const keys = Object.keys(record);
+          const placeholders = keys.map(() => "?").join(", ");
+          const values = keys.map((k) => {
+            const v = record[k];
+            if (typeof v === "boolean") return v ? 1 : 0;
+            if (Array.isArray(v) || typeof v === "object" && v !== null) return JSON.stringify(v);
+            return v;
+          });
+          await tx.execute(
+            `INSERT OR REPLACE INTO ${col} (${keys.join(", ")}) VALUES (${placeholders})`,
+            values
+          );
+        }
+      });
+      recordsRestored += records.length;
+    }
+  }
+  onProgress({ phase: "restoring", progress: 1, message: "Done" });
+  return {
+    operationsRestored: operations.length,
+    recordsRestored,
+    success: true,
+    duration: Date.now() - startTime
+  };
+}
+async function readVersionVector(adapter) {
+  const rows = await adapter.query(
+    "SELECT node_id, sequence_number FROM _kora_version_vector"
+  );
+  const vv = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    vv.set(row.node_id, row.sequence_number);
+  }
+  return vv;
+}
+async function readMeta(adapter) {
+  return adapter.query("SELECT key, value FROM _kora_meta");
+}
+async function readAllOperations(adapter, schema) {
+  const allOps = [];
+  for (const collectionName of Object.keys(schema.collections)) {
+    const rows = await adapter.query(
+      `SELECT * FROM _kora_ops_${collectionName} ORDER BY sequence_number ASC`
+    );
+    for (const row of rows) {
+      allOps.push(deserializeOperationWithCollection(row, collectionName));
+    }
+  }
+  return allOps;
+}
+async function readCollectionRecords(adapter, collection) {
+  return adapter.query(`SELECT * FROM ${collection} WHERE _deleted = 0`);
+}
+async function computeSha256(data) {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var import_core5, BACKUP_VERSION;
+var init_backup = __esm({
+  "src/backup/backup.ts"() {
+    "use strict";
+    import_core5 = require("@korajs/core");
+    init_serializer();
+    BACKUP_VERSION = 1;
+  }
+});
+
+// src/audit/audit-json.ts
+function auditJsonReplacer(_key, value) {
+  if (value instanceof Uint8Array) {
+    let binary = "";
+    for (let i = 0; i < value.length; i++) {
+      binary += String.fromCharCode(value[i]);
+    }
+    return { [WIRE_BYTES_KEY]: btoa(binary) };
+  }
+  return value;
+}
+function auditJsonReviver(_key, value) {
+  if (value !== null && typeof value === "object" && WIRE_BYTES_KEY in value && typeof value[WIRE_BYTES_KEY] === "string") {
+    const encoded = value[WIRE_BYTES_KEY];
+    if (typeof encoded !== "string") {
+      return value;
+    }
+    const binary = atob(encoded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  return value;
+}
+function serializeAuditJson(value) {
+  return JSON.stringify(value, auditJsonReplacer);
+}
+function deserializeAuditJson(json) {
+  return JSON.parse(json, auditJsonReviver);
+}
+var WIRE_BYTES_KEY;
+var init_audit_json = __esm({
+  "src/audit/audit-json.ts"() {
+    "use strict";
+    WIRE_BYTES_KEY = "__kora_bytes__";
+  }
+});
+
+// src/audit/audit-trace-store.ts
+var audit_trace_store_exports = {};
+__export(audit_trace_store_exports, {
+  appendAuditTrace: () => appendAuditTrace,
+  auditTraceIndexFields: () => auditTraceIndexFields,
+  countAuditTraces: () => countAuditTraces,
+  persistedAuditTraceFromEvent: () => persistedAuditTraceFromEvent,
+  readAuditTraces: () => readAuditTraces
+});
+function persistedAuditTraceFromEvent(event) {
+  return {
+    id: (0, import_core16.generateUUIDv7)(),
+    recordedAt: Date.now(),
+    eventType: event.type,
+    constraint: event.type === "constraint:violated" ? event.constraint : void 0,
+    trace: event.trace
+  };
+}
+async function appendAuditTrace(adapter, trace) {
+  const collection = trace.trace.operationA.collection;
+  const recordId = trace.trace.operationA.recordId;
+  await adapter.execute(
+    `INSERT INTO _kora_audit_traces (
+			id, recorded_at, event_type, collection, record_id, field, strategy, tier, constraint_name, trace_json
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      trace.id,
+      trace.recordedAt,
+      trace.eventType,
+      collection,
+      recordId,
+      trace.trace.field,
+      trace.trace.strategy,
+      trace.trace.tier,
+      trace.constraint ?? null,
+      serializeAuditJson(trace)
+    ]
+  );
+}
+async function readAuditTraces(adapter, query) {
+  const conditions = [];
+  const params = [];
+  if (query?.collections && query.collections.length > 0) {
+    const placeholders = query.collections.map(() => "?").join(", ");
+    conditions.push(`collection IN (${placeholders})`);
+    params.push(...query.collections);
+  }
+  if (query?.since !== void 0) {
+    conditions.push("recorded_at >= ?");
+    params.push(query.since);
+  }
+  if (query?.until !== void 0) {
+    conditions.push("recorded_at <= ?");
+    params.push(query.until);
+  }
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = await adapter.query(
+    `SELECT * FROM _kora_audit_traces ${whereClause} ORDER BY recorded_at ASC, id ASC`,
+    params
+  );
+  return rows.map(rowToPersistedTrace);
+}
+function rowToPersistedTrace(row) {
+  return deserializeAuditJson(row.trace_json);
+}
+async function countAuditTraces(adapter) {
+  const rows = await adapter.query(
+    "SELECT COUNT(*) as count FROM _kora_audit_traces"
+  );
+  return rows[0]?.count ?? 0;
+}
+function auditTraceIndexFields(trace) {
+  return {
+    collection: trace.operationA.collection,
+    recordId: trace.operationA.recordId
+  };
+}
+var import_core16;
+var init_audit_trace_store = __esm({
+  "src/audit/audit-trace-store.ts"() {
+    "use strict";
+    import_core16 = require("@korajs/core");
+    init_audit_json();
+  }
+});
+
+// src/audit/export-audit.ts
+var export_audit_exports = {};
+__export(export_audit_exports, {
+  decodeAuditExport: () => decodeAuditExport,
+  exportAudit: () => exportAudit,
+  readAuditExportManifest: () => readAuditExportManifest,
+  verifyAuditExportChecksum: () => verifyAuditExportChecksum
+});
+function encodeSection2(name, content) {
+  const nameBytes = new TextEncoder().encode(name);
+  const header = new Uint8Array(8);
+  const view = new DataView(header.buffer);
+  view.setUint32(0, nameBytes.length, true);
+  view.setUint32(4, content.length, true);
+  const result = new Uint8Array(header.length + nameBytes.length + content.length);
+  result.set(header, 0);
+  result.set(nameBytes, 8);
+  result.set(content, 8 + nameBytes.length);
+  return result;
+}
+function encodeJsonSection2(name, data) {
+  return encodeSection2(name, new TextEncoder().encode(serializeAuditJson(data)));
+}
+function encodeNdjsonSection(name, records) {
+  const lines = `${records.map((record) => serializeAuditJson(record)).join("\n")}
+`;
+  return encodeSection2(name, new TextEncoder().encode(lines));
+}
+function readUint322(view, offset) {
+  return view.getUint32(offset, true);
+}
+function parseSections2(data) {
+  const sections = [];
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let offset = 0;
+  while (offset + 8 <= data.byteLength) {
+    const nameLen = readUint322(view, offset);
+    const contentLen = readUint322(view, offset + 4);
+    offset += 8;
+    if (offset + nameLen + contentLen > data.byteLength) {
+      break;
+    }
+    const name = new TextDecoder().decode(data.slice(offset, offset + nameLen));
+    offset += nameLen;
+    const content = data.slice(offset, offset + contentLen);
+    offset += contentLen;
+    sections.push({ name, content });
+  }
+  return sections;
+}
+function findSection2(sections, name) {
+  for (const section of sections) {
+    if (section.name === name) {
+      return section.content;
+    }
+  }
+  return null;
+}
+async function computeSha2562(data) {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hashBuffer)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function readAllOperations2(adapter, schema, collectionFilter) {
+  const collections = collectionFilter ? Object.keys(schema.collections).filter((name) => collectionFilter.includes(name)) : Object.keys(schema.collections);
+  const allOps = [];
+  for (const collectionName of collections) {
+    const rows = await adapter.query(
+      `SELECT * FROM _kora_ops_${collectionName} ORDER BY sequence_number ASC`
+    );
+    for (const row of rows) {
+      allOps.push(deserializeOperationWithCollection(row, collectionName));
+    }
+  }
+  return allOps;
+}
+function filterOperationsByCollections(operations, collectionFilter) {
+  if (!collectionFilter || collectionFilter.length === 0) {
+    return operations;
+  }
+  const allowed = new Set(collectionFilter);
+  return operations.filter((op) => allowed.has(op.collection));
+}
+async function exportAudit(adapter, schema, nodeId, schemaVersion, options) {
+  const onProgress = options?.onProgress ?? (() => {
+  });
+  const traceQuery = {
+    collections: options?.collections,
+    since: options?.since,
+    until: options?.until
+  };
+  onProgress({ phase: "reading", progress: 0, message: "Reading operations" });
+  const operations = filterOperationsByCollections(
+    await readAllOperations2(adapter, schema, options?.collections),
+    options?.collections
+  );
+  onProgress({ phase: "reading", progress: 0.4, message: "Reading merge traces" });
+  const mergeTraces = await readAuditTraces(adapter, traceQuery);
+  onProgress({ phase: "writing", progress: 0.7, message: "Encoding audit export" });
+  const sections = [];
+  let contentForChecksum = new Uint8Array(0);
+  const addSection = (section) => {
+    sections.push(section);
+    const combined = new Uint8Array(contentForChecksum.length + section.length);
+    combined.set(contentForChecksum, 0);
+    combined.set(section, contentForChecksum.length);
+    contentForChecksum = combined;
+  };
+  addSection(encodeNdjsonSection("operations", operations));
+  addSection(encodeNdjsonSection("merge_traces", mergeTraces));
+  onProgress({ phase: "verifying", progress: 0.9, message: "Computing checksum" });
+  const checksum = await computeSha2562(contentForChecksum);
+  const manifest = {
+    version: 1,
+    exportedAt: Date.now(),
+    nodeId,
+    schemaVersion,
+    operationCount: operations.length,
+    mergeTraceCount: mergeTraces.length,
+    checksum
+  };
+  const manifestSection = encodeJsonSection2("manifest", manifest);
+  const checksumSection = encodeSection2("checksum", new TextEncoder().encode(checksum));
+  onProgress({ phase: "writing", progress: 1, message: "Finalizing" });
+  const parts = [manifestSection, ...sections, checksumSection];
+  const finalOutput = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    finalOutput.set(part, offset);
+    offset += part.length;
+  }
+  return finalOutput;
+}
+function decodeAuditExport(data) {
+  const sections = parseSections2(data);
+  const manifest = JSON.parse(
+    new TextDecoder().decode(findSection2(sections, "manifest") ?? new Uint8Array())
+  );
+  const operationsContent = findSection2(sections, "operations");
+  const mergeTracesContent = findSection2(sections, "merge_traces");
+  const operations = parseNdjsonSection(operationsContent);
+  const mergeTraces = parseNdjsonSection(mergeTracesContent);
+  return { manifest, operations, mergeTraces };
+}
+function readAuditExportManifest(data) {
+  const sections = parseSections2(data);
+  const manifestContent = findSection2(sections, "manifest");
+  if (!manifestContent) {
+    throw new Error("Invalid audit export: missing manifest section");
+  }
+  return JSON.parse(new TextDecoder().decode(manifestContent));
+}
+async function verifyAuditExportChecksum(data) {
+  const sections = parseSections2(data);
+  const manifest = readAuditExportManifest(data);
+  const contentSections = sections.filter(
+    (section) => section.name !== "manifest" && section.name !== "checksum"
+  );
+  let content = new Uint8Array(0);
+  for (const section of contentSections) {
+    const encoded = encodeSection2(section.name, section.content);
+    const combined = new Uint8Array(content.length + encoded.length);
+    combined.set(content, 0);
+    combined.set(encoded, content.length);
+    content = combined;
+  }
+  const checksum = await computeSha2562(content);
+  return checksum === manifest.checksum;
+}
+function parseNdjsonSection(content) {
+  if (!content || content.length === 0) {
+    return [];
+  }
+  const text = new TextDecoder().decode(content).trim();
+  if (text.length === 0) {
+    return [];
+  }
+  return text.split("\n").map((line) => deserializeAuditJson(line));
+}
+var init_export_audit = __esm({
+  "src/audit/export-audit.ts"() {
+    "use strict";
+    init_serializer();
+    init_audit_json();
+    init_audit_trace_store();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AdapterError: () => AdapterError,
+  COMPACTION_BASELINE_META_KEY: () => COMPACTION_BASELINE_META_KEY,
+  Collection: () => Collection,
+  InvalidStateTransitionError: () => InvalidStateTransitionError,
+  LAST_ACKED_SERVER_VECTOR_META_KEY: () => LAST_ACKED_SERVER_VECTOR_META_KEY,
+  PersistenceError: () => PersistenceError,
+  QueryBuilder: () => QueryBuilder,
+  QueryError: () => QueryError,
+  RecordNotFoundError: () => RecordNotFoundError,
+  SequenceManager: () => SequenceManager,
+  Store: () => Store,
+  StoreNotOpenError: () => StoreNotOpenError,
+  SubscriptionBloomFilter: () => SubscriptionBloomFilter,
+  SubscriptionManager: () => SubscriptionManager,
+  TransactionContext: () => TransactionContext,
+  WorkerInitError: () => WorkerInitError,
+  WorkerTimeoutError: () => WorkerTimeoutError,
+  collectOperationsAheadOfServer: () => collectOperationsAheadOfServer,
+  compactOperationLog: () => compactOperationLog,
+  computeAckCompactionWatermark: () => computeAckCompactionWatermark,
+  decodeAuditExport: () => decodeAuditExport,
+  decodeRichtext: () => decodeRichtext,
+  deserializeVersionVectorFromMeta: () => deserializeVersionVectorFromMeta,
+  encodeRichtext: () => encodeRichtext,
+  exportBackup: () => exportBackup,
+  mergeVersionVectors: () => mergeVersionVectors,
+  persistedAuditTraceFromEvent: () => persistedAuditTraceFromEvent,
+  pluralize: () => pluralize,
+  readAuditExportManifest: () => readAuditExportManifest,
+  readBackupManifest: () => readBackupManifest,
+  restoreBackup: () => restoreBackup,
+  richtextStatesEqual: () => richtextStatesEqual,
+  richtextToPlainText: () => richtextToPlainText,
+  serializeVersionVectorToMeta: () => serializeVersionVectorToMeta,
+  singularize: () => singularize,
+  validateStateTransition: () => validateStateTransition,
+  validateUpdateStateMachine: () => validateUpdateStateMachine,
+  verifyAuditExportChecksum: () => verifyAuditExportChecksum,
+  verifyBackupChecksum: () => verifyBackupChecksum
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var import_core = require("@korajs/core");
+var QueryError = class extends import_core.KoraError {
+  constructor(message, context) {
+    super(message, "QUERY_ERROR", context);
+    this.name = "QueryError";
+  }
+};
+var RecordNotFoundError = class extends import_core.KoraError {
+  constructor(collection, recordId) {
+    super(`Record "${recordId}" not found in collection "${collection}"`, "RECORD_NOT_FOUND", {
+      collection,
+      recordId
+    });
+    this.name = "RecordNotFoundError";
+  }
+};
+var AdapterError = class extends import_core.KoraError {
+  constructor(message, context) {
+    super(message, "ADAPTER_ERROR", context);
+    this.name = "AdapterError";
+  }
+};
+var StoreNotOpenError = class extends import_core.KoraError {
+  constructor() {
+    super("Store is not open. Call store.open() before performing operations.", "STORE_NOT_OPEN");
+    this.name = "StoreNotOpenError";
+  }
+};
+var WorkerInitError = class extends import_core.KoraError {
+  constructor(message, context) {
+    super(`Worker initialization failed: ${message}`, "WORKER_INIT_ERROR", context);
+    this.name = "WorkerInitError";
+  }
+};
+var WorkerTimeoutError = class extends import_core.KoraError {
+  constructor(operation, timeoutMs) {
+    super(
+      `Worker did not respond within ${timeoutMs}ms for operation "${operation}"`,
+      "WORKER_TIMEOUT",
+      { operation, timeoutMs }
+    );
+    this.name = "WorkerTimeoutError";
+  }
+};
+var PersistenceError = class extends import_core.KoraError {
+  constructor(message, context) {
+    super(`Persistence error: ${message}`, "PERSISTENCE_ERROR", context);
+    this.name = "PersistenceError";
+  }
+};
+
+// src/compaction/types.ts
+var COMPACTION_BASELINE_META_KEY = "compaction_baseline_at";
+
+// src/compaction/compact-operation-log.ts
+var import_core2 = require("@korajs/core");
+function computeAckCompactionWatermark(serverVector) {
+  const watermark = (0, import_core2.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: (0, import_core2.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 ? import_core2.HybridLogicalClock.serialize({
+    wallTime: ageCutoffWall,
+    logical: 0,
+    nodeId: ""
+  }).slice(0, 15) : null;
+  let deletedCount = 0;
+  const collectionNames = Object.keys(schema.collections);
+  await adapter.transaction(async (tx) => {
+    for (const collectionName of collectionNames) {
+      const table = `_kora_ops_${collectionName}`;
+      for (const [nodeId, maxSeq] of watermark) {
+        if (maxSeq <= 0) continue;
+        const countSql = buildCountSql(table, ageCutoffSerialized !== null);
+        const countParams = ageCutoffSerialized !== null ? [nodeId, maxSeq, ageCutoffSerialized] : [nodeId, maxSeq];
+        const countRows = await tx.query(countSql, countParams);
+        deletedCount += countRows[0]?.count ?? 0;
+        const deleteSql = buildDeleteSql(table, ageCutoffSerialized !== null);
+        await tx.execute(deleteSql, countParams);
+      }
+    }
+    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
+var import_core3 = require("@korajs/core");
+var LAST_ACKED_SERVER_VECTOR_META_KEY = "last_acked_server_vector";
+var DELTA_CURSOR_META_KEY = "delta_cursor";
+function serializeVersionVectorToMeta(vector) {
+  const record = {};
+  for (const [nodeId, seq] of vector) {
+    record[nodeId] = seq;
+  }
+  return JSON.stringify(record);
+}
+function deserializeVersionVectorFromMeta(value) {
+  const parsed = JSON.parse(value);
+  const vector = (0, import_core3.createVersionVector)();
+  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 (0, import_core3.createVersionVector)();
+  }
+  try {
+    return deserializeVersionVectorFromMeta(row.value);
+  } catch {
+    return (0, import_core3.createVersionVector)();
+  }
+}
+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
+  ]);
+}
+
+// src/store/store.ts
+var import_core17 = require("@korajs/core");
+init_backup();
+
+// src/mutations/execute-delete.ts
+var import_core7 = require("@korajs/core");
+
+// src/lww/row-version.ts
+var import_core6 = require("@korajs/core");
+var EMPTY_ROW_VERSION = "";
+function serializeRowVersion(timestamp) {
+  return import_core6.HybridLogicalClock.serialize(timestamp);
+}
+function rowVersionFromRecord(row) {
+  const version = row._version;
+  if (typeof version === "string" && version.length > 0) {
+    return import_core6.HybridLogicalClock.deserialize(version);
+  }
+  return { wallTime: row._updated_at, logical: 0, nodeId: "" };
+}
+function isIncomingNewerThanRow(incoming, row) {
+  return import_core6.HybridLogicalClock.compare(incoming, rowVersionFromRecord(row)) > 0;
+}
+function lwwVersionWhereClause(remoteVersion) {
+  return {
+    sql: "(_version = ? OR _version < ?)",
+    params: [EMPTY_ROW_VERSION, remoteVersion]
+  };
+}
+
+// src/query/sql-builder.ts
+function buildSelectQuery(descriptor, fields) {
+  const params = [];
+  const parts = [`SELECT * FROM ${descriptor.collection}`];
+  const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
+  const deletedFilter = "_deleted = 0";
+  if (whereClause) {
+    parts.push(`WHERE ${deletedFilter} AND ${whereClause}`);
+  } else {
+    parts.push(`WHERE ${deletedFilter}`);
+  }
+  if (descriptor.orderBy.length > 0) {
+    const orderParts = descriptor.orderBy.map((o) => {
+      validateFieldName(o.field, fields);
+      return `${o.field} ${o.direction.toUpperCase()}`;
+    });
+    parts.push(`ORDER BY ${orderParts.join(", ")}`);
+  }
+  if (descriptor.limit !== void 0) {
+    parts.push(`LIMIT ${descriptor.limit}`);
+  }
+  if (descriptor.offset !== void 0) {
+    parts.push(`OFFSET ${descriptor.offset}`);
+  }
+  return { sql: parts.join(" "), params };
+}
+function buildCountQuery(descriptor, fields) {
+  const params = [];
+  const parts = [`SELECT COUNT(*) as count FROM ${descriptor.collection}`];
+  const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
+  const deletedFilter = "_deleted = 0";
+  if (whereClause) {
+    parts.push(`WHERE ${deletedFilter} AND ${whereClause}`);
+  } else {
+    parts.push(`WHERE ${deletedFilter}`);
+  }
+  return { sql: parts.join(" "), params };
+}
+function buildInsertQuery(collection, record) {
+  const columns = Object.keys(record);
+  const placeholders = columns.map(() => "?");
+  const params = Object.values(record);
+  const sql = `INSERT INTO ${collection} (${columns.join(", ")}) VALUES (${placeholders.join(", ")})`;
+  return { sql, params };
+}
+function buildUpdateQuery(collection, id, changes) {
+  const setClauses = Object.keys(changes).map((col) => `${col} = ?`);
+  const params = [...Object.values(changes), id];
+  const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ?`;
+  return { sql, params };
+}
+function buildSoftDeleteQuery(collection, id, updatedAt, version) {
+  if (version !== void 0) {
+    return {
+      sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ?`,
+      params: [updatedAt, version, id]
+    };
+  }
+  return {
+    sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ? WHERE id = ?`,
+    params: [updatedAt, id]
+  };
+}
+function buildLwwUpdateQuery(collection, id, changes, remoteVersion) {
+  const setClauses = Object.keys(changes).map((col) => `${col} = ?`);
+  const lww = lwwVersionWhereClause(remoteVersion);
+  const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ? AND ${lww.sql}`;
+  const params = [...Object.values(changes), id, ...lww.params];
+  return { sql, params };
+}
+function buildLwwSoftDeleteQuery(collection, id, updatedAt, version) {
+  const lww = lwwVersionWhereClause(version);
+  return {
+    sql: `UPDATE ${collection} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ? AND ${lww.sql}`,
+    params: [updatedAt, version, id, ...lww.params]
+  };
+}
+var VALID_OPERATORS = /* @__PURE__ */ new Set(["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in"]);
+function buildWhereClauseParts(where, fields, params) {
+  const conditions = [];
+  for (const [fieldName, value] of Object.entries(where)) {
+    validateFieldName(fieldName, fields);
+    const descriptor = fields[fieldName];
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const ops = value;
+      for (const [op, opValue] of Object.entries(ops)) {
+        if (!VALID_OPERATORS.has(op)) {
+          throw new QueryError(`Unknown operator "${op}" on field "${fieldName}"`, {
+            field: fieldName,
+            operator: op,
+            validOperators: [...VALID_OPERATORS]
+          });
+        }
+        conditions.push(buildOperatorCondition(fieldName, op, opValue, descriptor, params));
+      }
+    } else {
+      conditions.push(buildOperatorCondition(fieldName, "$eq", value, descriptor, params));
+    }
+  }
+  if (conditions.length === 0) return null;
+  return conditions.join(" AND ");
+}
+function buildOperatorCondition(fieldName, operator, value, descriptor, params) {
+  const sqlValue = descriptor?.kind === "boolean" && typeof value === "boolean" ? value ? 1 : 0 : value;
+  switch (operator) {
+    case "$eq":
+      if (sqlValue === null) {
+        return `${fieldName} IS NULL`;
+      }
+      params.push(sqlValue);
+      return `${fieldName} = ?`;
+    case "$ne":
+      if (sqlValue === null) {
+        return `${fieldName} IS NOT NULL`;
+      }
+      params.push(sqlValue);
+      return `${fieldName} != ?`;
+    case "$gt":
+      params.push(sqlValue);
+      return `${fieldName} > ?`;
+    case "$gte":
+      params.push(sqlValue);
+      return `${fieldName} >= ?`;
+    case "$lt":
+      params.push(sqlValue);
+      return `${fieldName} < ?`;
+    case "$lte":
+      params.push(sqlValue);
+      return `${fieldName} <= ?`;
+    case "$in": {
+      if (!Array.isArray(sqlValue)) {
+        throw new QueryError(`$in operator requires an array value for field "${fieldName}"`, {
+          field: fieldName,
+          received: typeof sqlValue
+        });
+      }
+      const placeholders = sqlValue.map(() => "?");
+      for (const item of sqlValue) {
+        params.push(
+          descriptor?.kind === "boolean" && typeof item === "boolean" ? item ? 1 : 0 : item
+        );
       }
+      return `${fieldName} IN (${placeholders.join(", ")})`;
+    }
+    default:
+      throw new QueryError(`Unknown operator "${operator}"`, { operator });
+  }
+}
+function validateFieldName(fieldName, fields) {
+  const allowedFields = /* @__PURE__ */ new Set([
+    ...Object.keys(fields),
+    "id",
+    "createdAt",
+    "updatedAt",
+    "_created_at",
+    "_updated_at"
+  ]);
+  if (!allowedFields.has(fieldName)) {
+    throw new QueryError(
+      `Unknown field "${fieldName}" in query. Available fields: ${[...allowedFields].join(", ")}`,
+      { field: fieldName }
+    );
+  }
+}
+
+// src/mutations/execute-delete.ts
+init_serializer();
+
+// src/store/sequence-allocator.ts
+async function allocateNextSequenceNumber(adapter, nodeId) {
+  const rows = await adapter.query(
+    `INSERT INTO _kora_version_vector (node_id, sequence_number) VALUES (?, 1)
+     ON CONFLICT(node_id) DO UPDATE SET sequence_number = sequence_number + 1
+     RETURNING sequence_number`,
+    [nodeId]
+  );
+  const seq = rows[0]?.sequence_number;
+  if (seq === void 0) {
+    throw new Error(`Failed to allocate sequence number for node "${nodeId}"`);
+  }
+  return seq;
+}
+async function allocateNextSequenceInTransaction(tx, nodeId) {
+  const rows = await tx.query(
+    `INSERT INTO _kora_version_vector (node_id, sequence_number) VALUES (?, 1)
+     ON CONFLICT(node_id) DO UPDATE SET sequence_number = sequence_number + 1
+     RETURNING sequence_number`,
+    [nodeId]
+  );
+  const seq = rows[0]?.sequence_number;
+  if (seq === void 0) {
+    throw new Error(`Failed to allocate sequence number for node "${nodeId}" in transaction`);
+  }
+  return seq;
+}
+async function readSequenceNumber(adapter, nodeId) {
+  const rows = await adapter.query(
+    "SELECT sequence_number FROM _kora_version_vector WHERE node_id = ?",
+    [nodeId]
+  );
+  return rows[0]?.sequence_number ?? 0;
+}
+
+// src/mutations/resolve-causal-deps.ts
+function resolveCausalDeps(ctx) {
+  const merged = [];
+  for (const id of ctx.extraCausalDeps ?? []) {
+    if (!merged.includes(id)) {
+      merged.push(id);
+    }
+  }
+  for (const id of ctx.causalTracker?.nextCausalDeps(ctx.collection, ctx.inTransaction) ?? []) {
+    if (!merged.includes(id)) {
+      merged.push(id);
+    }
+  }
+  return merged;
+}
+
+// src/mutations/execute-delete.ts
+async function executeDelete(ctx, id, options) {
+  const currentRows = await ctx.adapter.query(
+    `SELECT * FROM ${ctx.collection} WHERE id = ? AND _deleted = 0`,
+    [id]
+  );
+  if (!currentRows[0]) {
+    throw new RecordNotFoundError(ctx.collection, id);
+  }
+  const causalDeps = resolveCausalDeps(ctx);
+  let operation = options?.operation;
+  const cascadedOps = [];
+  await ctx.adapter.transaction(async (tx) => {
+    if (!operation) {
+      const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
+      operation = await (0, import_core7.createOperation)(
+        {
+          nodeId: ctx.nodeId,
+          type: "delete",
+          collection: ctx.collection,
+          recordId: id,
+          data: null,
+          previousData: null,
+          sequenceNumber,
+          causalDeps,
+          schemaVersion: ctx.schema.version
+        },
+        ctx.clock
+      );
+      ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
+    }
+    if (ctx.relationEnforcer && !options?.skipReferentialEnforcement) {
+      const enforcementResult = await ctx.relationEnforcer.enforceDelete(ctx.collection, id, tx, [
+        operation.id
+      ]);
+      cascadedOps.push(...enforcementResult.operations);
+    }
+    const version = serializeRowVersion(operation.timestamp);
+    const deleteQuery = buildSoftDeleteQuery(
+      ctx.collection,
+      id,
+      operation.timestamp.wallTime,
+      version
+    );
+    const opInsert = buildInsertQuery(
+      `_kora_ops_${ctx.collection}`,
+      serializeOperation(operation)
+    );
+    await tx.execute(deleteQuery.sql, deleteQuery.params);
+    await tx.execute(opInsert.sql, opInsert.params);
+  });
+  if (!operation) {
+    throw new Error("Delete operation was not created");
+  }
+  ctx.onMutation(ctx.collection, operation);
+  for (const cascadedOp of cascadedOps) {
+    ctx.onMutation(cascadedOp.collection, cascadedOp);
+  }
+  return [operation, ...cascadedOps];
+}
+
+// src/mutations/execute-insert.ts
+var import_core8 = require("@korajs/core");
+init_serializer();
+async function executeInsert(ctx, data) {
+  const validated = (0, import_core8.validateRecord)(ctx.collection, ctx.definition, data, "insert");
+  const recordId = (0, import_core8.generateUUIDv7)();
+  for (const [fieldName, descriptor] of Object.entries(ctx.definition.fields)) {
+    if (descriptor.auto && descriptor.kind === "timestamp") {
+      validated[fieldName] = Date.now();
     }
-    const sequenceNumber = this.getSequenceNumber();
-    const operation = await (0, import_core3.createOperation)(
+  }
+  const causalDeps = resolveCausalDeps(ctx);
+  let operation;
+  let record;
+  await ctx.adapter.transaction(async (tx) => {
+    const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
+    operation = await (0, import_core8.createOperation)(
       {
-        nodeId: this.nodeId,
+        nodeId: ctx.nodeId,
         type: "insert",
-        collection: this.name,
+        collection: ctx.collection,
         recordId,
         data: { ...validated },
         previousData: null,
         sequenceNumber,
-        causalDeps: [],
-        schemaVersion: this.schema.version
+        causalDeps,
+        schemaVersion: ctx.schema.version
       },
-      this.clock
+      ctx.clock
     );
-    const serializedData = serializeRecord(validated, this.definition.fields);
-    const record = {
+    ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
+    const serializedData = serializeRecord(validated, ctx.definition.fields);
+    const version = serializeRowVersion(operation.timestamp);
+    record = {
       id: recordId,
       ...serializedData,
-      _created_at: now,
-      _updated_at: now
+      _created_at: operation.timestamp.wallTime,
+      _updated_at: operation.timestamp.wallTime,
+      _version: version
     };
-    const insertQuery = buildInsertQuery(this.name, record);
-    const opRow = serializeOperation(operation);
+    const builtInsert = buildInsertQuery(ctx.collection, record);
     const opInsert = buildInsertQuery(
-      `_kora_ops_${this.name}`,
-      opRow
+      `_kora_ops_${ctx.collection}`,
+      serializeOperation(operation)
     );
-    await this.adapter.transaction(async (tx) => {
-      await tx.execute(insertQuery.sql, insertQuery.params);
-      await tx.execute(opInsert.sql, opInsert.params);
-      await tx.execute(
-        "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-        [this.nodeId, sequenceNumber]
-      );
-    });
-    this.onMutation(this.name, operation);
-    return {
-      id: recordId,
-      ...validated,
-      createdAt: now,
-      updatedAt: now
-    };
-  }
-  /**
-   * Find a record by its ID. Returns null if not found or soft-deleted.
-   */
-  async findById(id) {
-    const rows = await this.adapter.query(
-      `SELECT * FROM ${this.name} WHERE id = ? AND _deleted = 0`,
-      [id]
+    await tx.execute(builtInsert.sql, builtInsert.params);
+    await tx.execute(opInsert.sql, opInsert.params);
+  });
+  ctx.onMutation(ctx.collection, operation);
+  return {
+    id: recordId,
+    ...validated,
+    createdAt: operation.timestamp.wallTime,
+    updatedAt: operation.timestamp.wallTime
+  };
+}
+
+// src/mutations/execute-update.ts
+var import_core10 = require("@korajs/core");
+init_serializer();
+
+// src/state-machine/state-validator.ts
+var import_core9 = require("@korajs/core");
+var InvalidStateTransitionError = class extends import_core9.KoraError {
+  constructor(collection, recordId, field, fromState, toState, allowedStates) {
+    super(
+      `Invalid state transition in collection "${collection}": cannot transition field "${field}" from "${fromState}" to "${toState}". Allowed transitions from "${fromState}": ${allowedStates.length > 0 ? allowedStates.join(", ") : "(none -- terminal state)"}`,
+      "INVALID_STATE_TRANSITION",
+      { collection, recordId, field, fromState, toState, allowedStates }
     );
-    const row = rows[0];
-    if (!row) return null;
-    return deserializeRecord(row, this.definition.fields);
+    this.collection = collection;
+    this.recordId = recordId;
+    this.field = field;
+    this.fromState = fromState;
+    this.toState = toState;
+    this.allowedStates = allowedStates;
+    this.name = "InvalidStateTransitionError";
   }
-  /**
-   * Update an existing record. Only the provided fields are changed.
-   *
-   * @param id - The record ID to update
-   * @param data - Partial data with only the fields to change
-   * @returns The updated record
-   * @throws {RecordNotFoundError} If the record doesn't exist or is deleted
-   */
-  async update(id, data) {
-    const currentRows = await this.adapter.query(
-      `SELECT * FROM ${this.name} WHERE id = ? AND _deleted = 0`,
-      [id]
+  collection;
+  recordId;
+  field;
+  fromState;
+  toState;
+  allowedStates;
+};
+function validateStateTransition(collectionName, recordId, stateMachine, currentState, newState) {
+  if (currentState === null) {
+    return { valid: true, allowedStates: [] };
+  }
+  if (currentState === newState) {
+    return { valid: true, allowedStates: stateMachine.transitions[currentState] ?? [] };
+  }
+  const constraint = {
+    field: stateMachine.field,
+    collection: collectionName,
+    transitions: stateMachine.transitions
+  };
+  const transitionResult = (0, import_core9.validateTransition)(constraint, currentState, newState);
+  if (transitionResult.valid) {
+    return { valid: true, allowedStates: transitionResult.allowedTargets };
+  }
+  const allowedStates = transitionResult.allowedTargets;
+  if (stateMachine.onInvalidTransition === "reject") {
+    throw new InvalidStateTransitionError(
+      collectionName,
+      recordId,
+      stateMachine.field,
+      currentState,
+      newState,
+      allowedStates
     );
-    const currentRow = currentRows[0];
-    if (!currentRow) {
-      throw new RecordNotFoundError(this.name, id);
-    }
-    const validated = (0, import_core3.validateRecord)(this.name, this.definition, data, "update");
-    const now = Date.now();
-    const previousData = {};
-    const currentRecord = deserializeRecord(currentRow, this.definition.fields);
-    for (const key of Object.keys(validated)) {
-      previousData[key] = currentRecord[key];
+  }
+  return { valid: false, allowedStates };
+}
+function validateUpdateStateMachine(collectionName, recordId, collectionDef, currentRecord, updateData) {
+  const stateMachine = collectionDef.stateMachine;
+  if (stateMachine === void 0) {
+    return updateData;
+  }
+  const stateField = stateMachine.field;
+  if (!(stateField in updateData)) {
+    return updateData;
+  }
+  const currentState = currentRecord[stateField];
+  const newState = updateData[stateField];
+  if (typeof currentState !== "string" || typeof newState !== "string") {
+    return updateData;
+  }
+  const result = validateStateTransition(
+    collectionName,
+    recordId,
+    stateMachine,
+    currentState,
+    newState
+  );
+  if (result.valid) {
+    return updateData;
+  }
+  const filtered = { ...updateData };
+  delete filtered[stateField];
+  return filtered;
+}
+
+// src/mutations/execute-update.ts
+async function executeUpdate(ctx, id, data) {
+  const currentRows = await ctx.adapter.query(
+    `SELECT * FROM ${ctx.collection} WHERE id = ? AND _deleted = 0`,
+    [id]
+  );
+  const currentRow = currentRows[0];
+  if (!currentRow) {
+    throw new RecordNotFoundError(ctx.collection, id);
+  }
+  let validated = (0, import_core10.validateRecord)(ctx.collection, ctx.definition, data, "update");
+  const currentRecord = deserializeRecord(currentRow, ctx.definition.fields);
+  validated = validateUpdateStateMachine(
+    ctx.collection,
+    id,
+    ctx.definition,
+    currentRecord,
+    validated
+  );
+  if (Object.keys(validated).length === 0) {
+    return { ...currentRecord };
+  }
+  const previousData = {};
+  const resolvedData = {};
+  const atomicOps = {};
+  for (const key of Object.keys(validated)) {
+    const value = validated[key];
+    previousData[key] = currentRecord[key];
+    if ((0, import_core10.isAtomicOp)(value)) {
+      resolvedData[key] = (0, import_core10.resolveAtomicOp)(currentRecord[key], value);
+      atomicOps[key] = (0, import_core10.toAtomicOp)(value);
+    } else {
+      resolvedData[key] = value;
     }
-    const sequenceNumber = this.getSequenceNumber();
-    const operation = await (0, import_core3.createOperation)(
+  }
+  const hasAtomicOps = Object.keys(atomicOps).length > 0;
+  const causalDeps = resolveCausalDeps(ctx);
+  let operation;
+  await ctx.adapter.transaction(async (tx) => {
+    const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
+    operation = await (0, import_core10.createOperation)(
       {
-        nodeId: this.nodeId,
+        nodeId: ctx.nodeId,
         type: "update",
-        collection: this.name,
+        collection: ctx.collection,
         recordId: id,
-        data: { ...validated },
+        data: { ...resolvedData },
         previousData,
         sequenceNumber,
-        causalDeps: [],
-        schemaVersion: this.schema.version
+        causalDeps,
+        schemaVersion: ctx.schema.version,
+        ...hasAtomicOps ? { atomicOps } : {}
       },
-      this.clock
+      ctx.clock
     );
-    const serializedChanges = serializeRecord(validated, this.definition.fields);
-    const updateQuery = buildUpdateQuery(this.name, id, {
+    ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
+    const serializedChanges = serializeRecord(resolvedData, ctx.definition.fields);
+    const version = serializeRowVersion(operation.timestamp);
+    const updateQuery = buildUpdateQuery(ctx.collection, id, {
       ...serializedChanges,
-      _updated_at: now
+      _updated_at: operation.timestamp.wallTime,
+      _version: version
     });
-    const opRow = serializeOperation(operation);
     const opInsert = buildInsertQuery(
-      `_kora_ops_${this.name}`,
-      opRow
+      `_kora_ops_${ctx.collection}`,
+      serializeOperation(operation)
     );
-    await this.adapter.transaction(async (tx) => {
-      await tx.execute(updateQuery.sql, updateQuery.params);
-      await tx.execute(opInsert.sql, opInsert.params);
-      await tx.execute(
-        "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-        [this.nodeId, sequenceNumber]
-      );
-    });
-    this.onMutation(this.name, operation);
-    const updatedRow = await this.findById(id);
-    if (!updatedRow) {
-      throw new RecordNotFoundError(this.name, id);
+    await tx.execute(updateQuery.sql, updateQuery.params);
+    await tx.execute(opInsert.sql, opInsert.params);
+  });
+  ctx.onMutation(ctx.collection, operation);
+  const rows = await ctx.adapter.query(
+    `SELECT * FROM ${ctx.collection} WHERE id = ? AND _deleted = 0`,
+    [id]
+  );
+  const row = rows[0];
+  if (!row) {
+    throw new RecordNotFoundError(ctx.collection, id);
+  }
+  return deserializeRecord(row, ctx.definition.fields);
+}
+
+// src/collection/collection.ts
+init_serializer();
+var Collection = class {
+  constructor(name, definition, schema, adapter, clock, nodeId, allocateSequenceNumber, onMutation, relationEnforcer, mutationHandler, causalTracker) {
+    this.name = name;
+    this.definition = definition;
+    this.schema = schema;
+    this.adapter = adapter;
+    this.clock = clock;
+    this.nodeId = nodeId;
+    this.allocateSequenceNumber = allocateSequenceNumber;
+    this.onMutation = onMutation;
+    this.relationEnforcer = relationEnforcer;
+    this.mutationHandler = mutationHandler;
+    this.causalTracker = causalTracker;
+  }
+  name;
+  definition;
+  schema;
+  adapter;
+  clock;
+  nodeId;
+  allocateSequenceNumber;
+  onMutation;
+  relationEnforcer;
+  mutationHandler;
+  causalTracker;
+  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
+    };
+  }
+  async insert(data) {
+    if (this.mutationHandler) {
+      return this.mutationHandler.insert(this.name, data);
     }
-    return updatedRow;
+    return executeInsert(this.mutationContext(), data);
   }
-  /**
-   * Soft-delete a record by its ID.
-   *
-   * @param id - The record ID to delete
-   * @throws {RecordNotFoundError} If the record doesn't exist or is already deleted
-   */
-  async delete(id) {
-    const currentRows = await this.adapter.query(
+  async findById(id) {
+    const rows = await this.adapter.query(
       `SELECT * FROM ${this.name} WHERE id = ? AND _deleted = 0`,
       [id]
     );
-    if (!currentRows[0]) {
-      throw new RecordNotFoundError(this.name, 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);
     }
-    const now = Date.now();
-    const sequenceNumber = this.getSequenceNumber();
-    const operation = await (0, import_core3.createOperation)(
-      {
-        nodeId: this.nodeId,
-        type: "delete",
-        collection: this.name,
-        recordId: id,
-        data: null,
-        previousData: null,
-        sequenceNumber,
-        causalDeps: [],
-        schemaVersion: this.schema.version
-      },
-      this.clock
-    );
-    const deleteQuery = buildSoftDeleteQuery(this.name, id, now);
-    const opRow = serializeOperation(operation);
-    const opInsert = buildInsertQuery(
-      `_kora_ops_${this.name}`,
-      opRow
-    );
-    await this.adapter.transaction(async (tx) => {
-      await tx.execute(deleteQuery.sql, deleteQuery.params);
-      await tx.execute(opInsert.sql, opInsert.params);
-      await tx.execute(
-        "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
-        [this.nodeId, sequenceNumber]
-      );
-    });
-    this.onMutation(this.name, operation);
+    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);
   }
-  /** Get the collection name */
   getName() {
     return this.name;
   }
-  /** Get the collection definition */
   getDefinition() {
     return this.definition;
   }
+  /** Replace the mutation handler (e.g. after ApplyPipeline is wired in createApp). */
+  setMutationHandler(handler) {
+    this.mutationHandler = handler;
+  }
 };
 
+// src/query/query-builder.ts
+init_serializer();
+
 // src/query/pluralize.ts
 function isVowel(char) {
   if (!char) return false;
@@ -847,62 +2032,709 @@ var QueryBuilder = class _QueryBuilder {
     }
   }
   /**
-   * One-to-many: collect primary IDs, batch-fetch children, attach as array.
+   * 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 ${relatedCollection} WHERE ${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
+var import_core11 = require("@korajs/core");
+init_serializer();
+
+// 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 import_core11.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 ${sourceCollection} WHERE ${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 (0, import_core11.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 ${sourceCollection} WHERE ${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 (0, import_core11.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 ${sourceCollection} WHERE ${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
+var import_core12 = require("@korajs/core");
+var import_internal = require("@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 import_core12.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 (0, import_internal.topologicalSort)(subset);
+}
+function buildReplaySnapshot(schema, allOps, targetOperationId) {
+  const operationsApplied = collectCausalClosure(allOps, targetOperationId);
+  const targetOperation = operationsApplied.find((op) => op.id === targetOperationId);
+  if (!targetOperation) {
+    throw new import_core12.OperationError(`Operation "${targetOperationId}" not found after causal sort`, {
+      operationId: targetOperationId
+    });
+  }
+  const memory = /* @__PURE__ */ new Map();
+  for (const op of operationsApplied) {
+    applyOperationToMemory(memory, op, schema);
+  }
+  const collections = materializeCollections(schema, memory);
+  return {
+    targetOperation,
+    operationsApplied,
+    collections,
+    findRecord(collection, recordId) {
+      const colMap = memory.get(collection);
+      const record = colMap?.get(recordId);
+      if (!record || record.deleted) {
+        return null;
+      }
+      const definition = schema.collections[collection];
+      if (!definition) {
+        return null;
+      }
+      return toCollectionRecord(record, definition);
+    }
+  };
+}
+function applyOperationToMemory(state, op, schema) {
+  const definition = schema.collections[op.collection];
+  if (!definition) {
+    return;
+  }
+  let colMap = state.get(op.collection);
+  if (!colMap) {
+    colMap = /* @__PURE__ */ new Map();
+    state.set(op.collection, colMap);
+  }
+  const wallTime = op.timestamp.wallTime;
+  switch (op.type) {
+    case "insert": {
+      if (!op.data) {
+        return;
+      }
+      colMap.set(op.recordId, {
+        id: op.recordId,
+        fields: { ...op.data },
+        deleted: false,
+        createdAt: wallTime,
+        updatedAt: wallTime
+      });
+      break;
+    }
+    case "update": {
+      if (!op.data) {
+        return;
+      }
+      const existing = colMap.get(op.recordId);
+      if (existing && !existing.deleted) {
+        existing.fields = { ...existing.fields, ...op.data };
+        existing.updatedAt = wallTime;
+        break;
+      }
+      if (existing?.deleted) {
+        return;
+      }
+      colMap.set(op.recordId, {
+        id: op.recordId,
+        fields: { ...op.data },
+        deleted: false,
+        createdAt: wallTime,
+        updatedAt: wallTime
+      });
+      break;
+    }
+    case "delete": {
+      const existing = colMap.get(op.recordId);
+      if (existing) {
+        existing.deleted = true;
+        existing.updatedAt = wallTime;
+        return;
+      }
+      colMap.set(op.recordId, {
+        id: op.recordId,
+        fields: {},
+        deleted: true,
+        createdAt: wallTime,
+        updatedAt: wallTime
+      });
+      break;
+    }
+  }
+}
+function materializeCollections(schema, memory) {
+  const collections = {};
+  for (const [collectionName, definition] of Object.entries(schema.collections)) {
+    const colMap = memory.get(collectionName);
+    const records = [];
+    if (colMap) {
+      for (const record of colMap.values()) {
+        if (!record.deleted) {
+          records.push(toCollectionRecord(record, definition));
+        }
+      }
+    }
+    collections[collectionName] = records;
+  }
+  return collections;
+}
+function toCollectionRecord(record, definition) {
+  const result = {
+    id: record.id,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  };
+  for (const [fieldName] of Object.entries(definition.fields)) {
+    if (fieldName in record.fields) {
+      result[fieldName] = record.fields[fieldName];
+    }
+  }
+  return result;
+}
+
+// src/sequences/sequence-manager.ts
+var import_core13 = require("@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 ?? (0, import_core13.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 (0, import_core13.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/store/store.ts
+init_serializer();
+
+// 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.
    */
-  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 ${relatedCollection} WHERE ${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, []);
+  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++;
       }
-      grouped.get(fk)?.push(r);
-    }
-    const propName = pluralize(target);
-    for (const record of records) {
-      ;
-      record[propName] = grouped.get(record.id) ?? [];
     }
+    return count;
   }
   /**
-   * Find a relation definition matching the include target.
-   * Searches by relation name, target collection name, and singularized/pluralized variants.
+   * 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.
    */
-  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;
+  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 null;
-  }
-};
-var QueryError2 = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "QueryError";
+    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.
    *
@@ -921,8 +2753,12 @@ var SubscriptionManager = class {
       lastResults: []
     };
     this.subscriptions.set(id, subscription);
+    this.bloomDirty = true;
+    const externalCleanup = this.onQuerySubscribed?.(descriptor);
     return () => {
       this.subscriptions.delete(id);
+      this.bloomDirty = true;
+      externalCleanup?.();
     };
   }
   /**
@@ -942,6 +2778,8 @@ var SubscriptionManager = class {
       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;
@@ -950,6 +2788,8 @@ var SubscriptionManager = class {
     });
     return () => {
       this.subscriptions.delete(id);
+      this.bloomDirty = true;
+      externalCleanup?.();
     };
   }
   /**
@@ -969,78 +2809,586 @@ var SubscriptionManager = class {
     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;
           }
         }
       }
     }
-    for (const sub of affected) {
-      try {
-        const newResults = await sub.executeFn();
-        if (!this.resultsEqual(sub.lastResults, newResults)) {
-          sub.lastResults = newResults;
-          sub.callback(newResults);
-        }
-      } catch {
+    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/transaction/transaction-context.ts
+var import_core14 = require("@korajs/core");
+init_serializer();
+var TransactionContext = class {
+  transactionId;
+  mutationName;
+  buffer = [];
+  committed = false;
+  rolledBack = false;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.transactionId = (0, import_core14.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 = (0, import_core14.validateRecord)(collectionName, definition, data, "insert");
+    const recordId = (0, import_core14.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 (0, import_core14.createOperation)(
+      {
+        nodeId: this.config.nodeId,
+        type: "insert",
+        collection: collectionName,
+        recordId,
+        data: { ...validated },
+        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 = (0, import_core14.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 ((0, import_core14.isAtomicOp)(value)) {
+        resolvedData[key] = (0, import_core14.resolveAtomicOp)(currentRecord[key], value);
+        atomicOps[key] = (0, import_core14.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 (0, import_core14.createOperation)(
+      {
+        nodeId: this.config.nodeId,
+        type: "update",
+        collection: collectionName,
+        recordId: id,
+        data: { ...resolvedData },
+        previousData,
+        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 (0, import_core14.createOperation)(
+      {
+        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 ${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,
+          ...entry.operation.data,
+          createdAt: entry.operation.timestamp.wallTime,
+          updatedAt: entry.operation.timestamp.wallTime
+        };
+      } else if (entry.operation.type === "update" && entry.operation.data && record) {
+        record = {
+          ...record,
+          ...entry.operation.data,
+          updatedAt: entry.operation.timestamp.wallTime
+        };
+      } else if (entry.operation.type === "delete") {
+        record = null;
       }
     }
+    return record;
   }
-  /**
-   * Remove all subscriptions. Called on store close.
-   */
-  clear() {
-    this.subscriptions.clear();
-    this.pendingCollections.clear();
-    this.flushScheduled = false;
-  }
-  /** Number of active subscriptions (for testing/debugging) */
-  get size() {
-    return this.subscriptions.size;
+};
+
+// src/transaction/transaction-sequence.ts
+var TransactionSequenceAllocator = class {
+  constructor(adapter, nodeId) {
+    this.adapter = adapter;
+    this.nodeId = nodeId;
   }
-  scheduleFlush() {
-    if (this.flushScheduled) return;
-    this.flushScheduled = true;
-    queueMicrotask(() => {
-      this.flush();
-    });
+  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;
   }
-  /**
-   * Compare two result sets. Uses length check + JSON comparison as pragmatic approach.
-   * Sufficient for typical query results. Can be optimized to id-based diffing if profiling shows need.
-   */
-  resultsEqual(prev, next) {
-    if (prev.length !== next.length) return false;
-    if (prev.length === 0) return true;
-    return JSON.stringify(prev) === JSON.stringify(next);
+  getHighWaterMark() {
+    return this.watermark;
   }
 };
 
+// src/store/tab-node-id.ts
+var import_core15 = require("@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 = (0, import_core15.generateUUIDv7)();
+  savePerTabNodeId(dbName, nodeId);
+  return nodeId;
+}
+
 // src/store/store.ts
 var Store = class {
   opened = false;
   nodeId = "";
   sequenceNumber = 0;
-  versionVector = (0, import_core4.createVersionVector)();
+  versionVector = (0, import_core17.createVersionVector)();
   clock = null;
   collections = /* @__PURE__ */ new Map();
-  subscriptionManager = new SubscriptionManager();
+  subscriptionManager;
+  sequenceManager = null;
   schema;
   adapter;
   configNodeId;
+  dbName;
+  isolation;
   emitter;
+  localMutationHandler;
+  relationEnforcer = null;
+  causalTracker = null;
   constructor(config) {
     this.schema = config.schema;
     this.adapter = config.adapter;
     this.configNodeId = config.nodeId;
+    this.dbName = config.dbName ?? "kora-db";
+    this.isolation = config.isolation ?? "shared";
     this.emitter = config.emitter ?? null;
+    this.localMutationHandler = config.localMutationHandler ?? null;
+    this.subscriptionManager = new SubscriptionManager({
+      onQuerySubscribed: config.onQuerySubscribed
+    });
   }
   /**
    * Open the store: initialize the database, load or generate a node ID,
@@ -1048,10 +3396,20 @@ var Store = class {
    */
   async open() {
     await this.adapter.open(this.schema);
+    await this.runMigrationsIfNeeded();
     this.nodeId = await this.loadOrGenerateNodeId();
-    this.clock = new import_core4.HybridLogicalClock(this.nodeId);
+    this.clock = new import_core17.HybridLogicalClock(this.nodeId);
+    this.causalTracker = new import_core17.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,
@@ -1060,13 +3418,17 @@ var Store = class {
         this.adapter,
         this.clock,
         this.nodeId,
-        () => this.nextSequenceNumber(),
+        () => this.allocateSequenceNumber(),
         (collectionName, operation) => {
+          this.recordOperationSequence(operation);
           this.subscriptionManager.notify(collectionName, operation);
           if (this.emitter) {
             this.emitter.emit({ type: "operation:created", operation });
           }
-        }
+        },
+        this.relationEnforcer,
+        this.localMutationHandler,
+        this.causalTracker
       );
       this.collections.set(name, col);
     }
@@ -1103,7 +3465,14 @@ var Store = class {
       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)
+      where: (conditions) => new QueryBuilder(
+        name,
+        definition,
+        this.adapter,
+        this.subscriptionManager,
+        conditions,
+        this.schema
+      )
     };
   }
   /**
@@ -1125,7 +3494,7 @@ var Store = class {
    * Checks for duplicates, applies to the data table, persists the operation,
    * and updates the version vector.
    */
-  async applyRemoteOperation(op) {
+  async applyRemoteOperation(op, options) {
     this.ensureOpen();
     const collection = op.collection;
     const definition = this.schema.collections[collection];
@@ -1142,27 +3511,52 @@ var Store = class {
     if (this.clock) {
       this.clock.receive(op.timestamp);
     }
+    const remoteVersion = serializeRowVersion(op.timestamp);
+    const wallTime = op.timestamp.wallTime;
     await this.adapter.transaction(async (tx) => {
       if (op.type === "insert" && op.data) {
-        const serializedData = serializeRecord(op.data, definition.fields);
-        const now = op.timestamp.wallTime;
-        const record = {
-          id: op.recordId,
-          ...serializedData,
-          _created_at: now,
-          _updated_at: now
-        };
-        const insertQuery = buildInsertQuery(collection, record);
-        await tx.execute(insertQuery.sql, insertQuery.params);
+        const existing2 = await tx.query(
+          `SELECT _updated_at, _version FROM ${collection} WHERE id = ?`,
+          [op.recordId]
+        );
+        const row = existing2[0];
+        if (row && !isIncomingNewerThanRow(op.timestamp, row)) {
+        } else {
+          const serializedData = serializeRecord(op.data, definition.fields);
+          const record = {
+            id: op.recordId,
+            ...serializedData,
+            _created_at: wallTime,
+            _updated_at: wallTime,
+            _version: remoteVersion
+          };
+          const insertQuery = buildInsertQuery(collection, record);
+          await tx.execute(insertQuery.sql, insertQuery.params);
+        }
       } else if (op.type === "update" && op.data) {
         const serializedChanges = serializeRecord(op.data, definition.fields);
-        const updateQuery = buildUpdateQuery(collection, op.recordId, {
+        const updatePayload = {
           ...serializedChanges,
-          _updated_at: op.timestamp.wallTime
-        });
+          _updated_at: wallTime,
+          _version: remoteVersion
+        };
+        if (options?.reactivateIfDeleted) {
+          updatePayload._deleted = 0;
+        }
+        const updateQuery = buildLwwUpdateQuery(
+          collection,
+          op.recordId,
+          updatePayload,
+          remoteVersion
+        );
         await tx.execute(updateQuery.sql, updateQuery.params);
       } else if (op.type === "delete") {
-        const deleteQuery = buildSoftDeleteQuery(collection, op.recordId, op.timestamp.wallTime);
+        const deleteQuery = buildLwwSoftDeleteQuery(
+          collection,
+          op.recordId,
+          wallTime,
+          remoteVersion
+        );
         await tx.execute(deleteQuery.sql, deleteQuery.params);
       }
       const opRow = serializeOperation(op);
@@ -1187,11 +3581,11 @@ var Store = class {
    * Get operations from a node within a sequence number range.
    * Implements the OperationLog interface for computeDelta.
    */
-  getRange(nodeId, fromSeq, toSeq) {
-    return [];
+  async getRange(nodeId, fromSeq, toSeq) {
+    return this.getOperationRange(nodeId, fromSeq, toSeq);
   }
   /**
-   * Async version of getRange for use by the sync layer.
+   * Get operations from a node within a sequence number range.
    */
   async getOperationRange(nodeId, fromSeq, toSeq) {
     this.ensureOpen();
@@ -1208,36 +3602,449 @@ var Store = class {
     allOps.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
     return allOps;
   }
+  /**
+   * Load every operation from the local append-only log across all collections.
+   * Used by sync delta computation, backup export, and time-travel replay.
+   */
+  async getAllOperations() {
+    this.ensureOpen();
+    const allOps = [];
+    for (const collectionName of Object.keys(this.schema.collections)) {
+      const rows = await this.adapter.query(
+        `SELECT * FROM _kora_ops_${collectionName} ORDER BY sequence_number ASC`
+      );
+      for (const row of rows) {
+        allOps.push(deserializeOperationWithCollection(row, collectionName));
+      }
+    }
+    return allOps;
+  }
+  /**
+   * Rebuild an in-memory snapshot of materialized state at a causal cut in the op log.
+   * Does not mutate the live store — intended for DevTools time-travel inspection.
+   *
+   * @param operationId - Content-addressed id of the operation to replay through (inclusive)
+   * @throws {OperationError} When the operation id is not present in the local log
+   */
+  async replayTo(operationId) {
+    this.ensureOpen();
+    const start = Date.now();
+    const allOps = await this.getAllOperations();
+    const snapshot = buildReplaySnapshot(this.schema, allOps, operationId);
+    if (this.emitter) {
+      this.emitter.emit({
+        type: "replay:completed",
+        targetOperationId: operationId,
+        operationsApplied: snapshot.operationsApplied.length,
+        duration: Date.now() - start
+      });
+    }
+    return snapshot;
+  }
+  /**
+   * Persist a merge trace to the durable audit log.
+   */
+  async appendAuditTrace(trace) {
+    this.ensureOpen();
+    const { appendAuditTrace: append } = await Promise.resolve().then(() => (init_audit_trace_store(), audit_trace_store_exports));
+    await append(this.adapter, trace);
+  }
+  /**
+   * Read persisted audit traces with optional filters.
+   */
+  async getAuditTraces(query) {
+    this.ensureOpen();
+    const { readAuditTraces: readAuditTraces2 } = await Promise.resolve().then(() => (init_audit_trace_store(), audit_trace_store_exports));
+    return readAuditTraces2(this.adapter, query);
+  }
+  /**
+   * Export operations and merge traces as a portable audit bundle.
+   */
+  async exportAudit(options) {
+    this.ensureOpen();
+    const { exportAudit: doExport } = await Promise.resolve().then(() => (init_export_audit(), export_audit_exports));
+    return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
+  }
   /**
    * Get the schema definition.
    */
   getSchema() {
     return this.schema;
   }
+  /**
+   * Route local CRUD through the unified apply pipeline (korajs ApplyPipeline).
+   */
+  setLocalMutationHandler(handler) {
+    this.localMutationHandler = handler;
+    for (const col of this.collections.values()) {
+      col.setMutationHandler(handler);
+    }
+  }
+  /**
+   * Build mutation context for a collection (used by ApplyPipeline side effects).
+   */
+  createMutationContext(collection, options) {
+    this.ensureOpen();
+    const definition = this.schema.collections[collection];
+    if (!definition || !this.clock) {
+      throw new StoreNotOpenError();
+    }
+    return {
+      collection,
+      definition,
+      schema: this.schema,
+      adapter: this.adapter,
+      clock: this.clock,
+      nodeId: this.nodeId,
+      allocateSequenceNumber: () => this.allocateSequenceNumber(),
+      onMutation: (collectionName, operation) => {
+        this.recordOperationSequence(operation);
+        this.subscriptionManager.notify(collectionName, operation);
+        if (this.emitter) {
+          this.emitter.emit({ type: "operation:created", operation });
+        }
+      },
+      relationEnforcer: this.relationEnforcer,
+      causalTracker: this.causalTracker,
+      inTransaction: options?.inTransaction ?? false,
+      extraCausalDeps: options?.extraCausalDeps
+    };
+  }
+  /**
+   * Load a materialized row by ID, including soft-deleted tombstones.
+   */
+  async findMaterializedRow(collection, recordId) {
+    this.ensureOpen();
+    const definition = this.schema.collections[collection];
+    if (!definition) {
+      return null;
+    }
+    const rows = await this.adapter.query(
+      `SELECT * FROM ${collection} WHERE id = ?`,
+      [recordId]
+    );
+    const row = rows[0];
+    if (!row) {
+      return null;
+    }
+    return {
+      record: deserializeRecord(row, definition.fields),
+      deleted: row._deleted === 1
+    };
+  }
+  /**
+   * Latest operation from this device for a record (used for delete-vs-update merge on sync).
+   */
+  /**
+   * Load the last server version vector acknowledged by this client (persisted in `_kora_meta`).
+   */
+  async loadLastAckedServerVector() {
+    this.ensureOpen();
+    return loadLastAckedServerVector(this.adapter);
+  }
+  /**
+   * Persist the last server version vector this client believes the server has applied.
+   */
+  async saveLastAckedServerVector(vector) {
+    this.ensureOpen();
+    await saveLastAckedServerVector(this.adapter, vector);
+  }
+  /**
+   * Load persisted delta cursor for resuming paginated initial sync.
+   */
+  async loadDeltaCursor() {
+    this.ensureOpen();
+    return loadDeltaCursor(this.adapter);
+  }
+  /**
+   * Persist or clear the delta cursor for paginated initial sync resume.
+   */
+  async saveDeltaCursor(cursor) {
+    this.ensureOpen();
+    await saveDeltaCursor(this.adapter, cursor);
+  }
+  /**
+   * Local operations not yet reflected on the server version vector.
+   */
+  async getUnsyncedOperations(serverVector) {
+    this.ensureOpen();
+    return collectOperationsAheadOfServer(
+      this.getVersionVector(),
+      serverVector,
+      (nodeId, fromSeq, toSeq) => this.getOperationRange(nodeId, fromSeq, toSeq)
+    );
+  }
+  /**
+   * Count of local operations ahead of the server version vector.
+   */
+  async countUnsyncedOperations(serverVector) {
+    const ops = await this.getUnsyncedOperations(serverVector);
+    return ops.length;
+  }
+  /**
+   * Compact the local operation log using materialized rows as the baseline.
+   * Only removes ops the server has acknowledged (per {@link CompactionStrategy}).
+   */
+  async compact(strategy) {
+    this.ensureOpen();
+    if (strategy.mode === "never") {
+      return compactOperationLog(this.adapter, this.schema, strategy, (0, import_core17.createVersionVector)());
+    }
+    const serverVector = strategy.serverVector ?? await loadLastAckedServerVector(this.adapter);
+    return compactOperationLog(this.adapter, this.schema, strategy, serverVector);
+  }
+  /**
+   * Merge session remote vector with persisted last-acked vector (max per node).
+   */
+  mergeServerVectors(sessionVector, persistedVector) {
+    return mergeVersionVectors(persistedVector, sessionVector);
+  }
+  async getLatestLocalOperationForRecord(collection, recordId) {
+    this.ensureOpen();
+    const rows = await this.adapter.query(
+      `SELECT * FROM _kora_ops_${collection} WHERE node_id = ? AND record_id = ? ORDER BY sequence_number DESC LIMIT 1`,
+      [this.nodeId, recordId]
+    );
+    const row = rows[0];
+    if (!row) {
+      return null;
+    }
+    return deserializeOperationWithCollection(row, collection);
+  }
+  /**
+   * Latest operation for a record from any node (for 3-way merge when local op log is empty).
+   */
+  async getLatestOperationForRecord(collection, recordId) {
+    this.ensureOpen();
+    const rows = await this.adapter.query(
+      `SELECT * FROM _kora_ops_${collection} WHERE record_id = ?`,
+      [recordId]
+    );
+    let latest = null;
+    for (const row of rows) {
+      const op = deserializeOperationWithCollection(row, collection);
+      if (!latest || import_core17.HybridLogicalClock.compare(op.timestamp, latest.timestamp) > 0) {
+        latest = op;
+      }
+    }
+    return latest;
+  }
   /** Expose the subscription manager for direct access (e.g., by QueryBuilder) */
   getSubscriptionManager() {
     return this.subscriptionManager;
   }
-  nextSequenceNumber() {
-    this.sequenceNumber++;
-    this.versionVector.set(this.nodeId, this.sequenceNumber);
-    return this.sequenceNumber;
+  /**
+   * 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;
+  }
+  /**
+   * 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.
+   */
+  createTransaction() {
+    this.ensureOpen();
+    if (!this.clock) {
+      throw new StoreNotOpenError();
+    }
+    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 });
+        }
+      }
+      return operations;
+    } catch (error) {
+      tx.rollback();
+      this.causalTracker?.clearTransaction();
+      throw error;
+    }
+  }
+  /**
+   * 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 Promise.resolve().then(() => (init_backup(), backup_exports));
+    return doExport(this.adapter, this.schema, this.nodeId, this.schema.version, options);
+  }
+  /**
+   * Restore data from a backup binary.
+   *
+   * @param data - The backup data
+   * @param options - Restore options (merge, collections, onProgress)
+   * @returns Result of the restore operation
+   */
+  async importBackup(data, options) {
+    this.ensureOpen();
+    const { restoreBackup: doRestore } = await Promise.resolve().then(() => (init_backup(), backup_exports));
+    return doRestore(this.adapter, this.schema, data, options);
+  }
+  /**
+   * Read backup manifest without loading the entire backup.
+   *
+   * @param data - The raw backup data
+   * @returns The backup manifest
+   */
+  static readBackupManifest(data) {
+    return readBackupManifest(data);
+  }
+  recordOperationSequence(operation) {
+    const prev = this.versionVector.get(operation.nodeId) ?? 0;
+    if (operation.sequenceNumber > prev) {
+      this.versionVector.set(operation.nodeId, operation.sequenceNumber);
+    }
+    if (operation.nodeId === this.nodeId) {
+      this.sequenceNumber = Math.max(this.sequenceNumber, operation.sequenceNumber);
+    }
+  }
+  async allocateSequenceNumber() {
+    const seq = await allocateNextSequenceNumber(this.adapter, this.nodeId);
+    this.sequenceNumber = seq;
+    this.versionVector.set(this.nodeId, seq);
+    return seq;
+  }
+  /**
+   * Check the stored schema version and run any pending migrations.
+   * 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 = (0, import_core17.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)]
+    );
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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 ${collection} WHERE _deleted = 0`
+    );
+    await this.adapter.transaction(async (tx) => {
+      for (const row of rows) {
+        const updates = transform(row);
+        const fields = Object.keys(updates);
+        if (fields.length === 0) continue;
+        const setClauses = fields.map((f) => `${f} = ?`).join(", ");
+        const 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 ${collection} SET ${setClauses} WHERE id = ?`, values);
+      }
+    });
   }
   async loadOrGenerateNodeId() {
     if (this.configNodeId) {
-      await this.adapter.execute(
-        "INSERT OR REPLACE INTO _kora_meta (key, value) VALUES ('node_id', ?)",
-        [this.configNodeId]
-      );
+      if (this.isolation !== "per-tab") {
+        await this.adapter.execute(
+          "INSERT OR REPLACE INTO _kora_meta (key, value) VALUES ('node_id', ?)",
+          [this.configNodeId]
+        );
+      }
       return this.configNodeId;
     }
+    if (this.isolation === "per-tab") {
+      return resolvePerTabNodeId(this.dbName);
+    }
     const rows = await this.adapter.query(
       "SELECT value FROM _kora_meta WHERE key = 'node_id'"
     );
     if (rows[0]) {
       return rows[0].value;
     }
-    const newNodeId = (0, import_core4.generateUUIDv7)();
+    const newNodeId = (0, import_core17.generateUUIDv7)();
     await this.adapter.execute("INSERT INTO _kora_meta (key, value) VALUES ('node_id', ?)", [
       newNodeId
     ]);
@@ -1254,7 +4061,7 @@ var Store = class {
     const rows = await this.adapter.query(
       "SELECT node_id, sequence_number FROM _kora_version_vector"
     );
-    const vector = (0, import_core4.createVersionVector)();
+    const vector = (0, import_core17.createVersionVector)();
     for (const row of rows) {
       vector.set(row.node_id, row.sequence_number);
     }
@@ -1266,23 +4073,57 @@ var Store = class {
     }
   }
 };
+
+// src/index.ts
+init_richtext_serializer();
+
+// src/backup/index.ts
+init_backup();
+
+// src/audit/index.ts
+init_audit_trace_store();
+init_audit_json();
+init_export_audit();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AdapterError,
+  COMPACTION_BASELINE_META_KEY,
   Collection,
+  InvalidStateTransitionError,
+  LAST_ACKED_SERVER_VECTOR_META_KEY,
   PersistenceError,
   QueryBuilder,
   QueryError,
   RecordNotFoundError,
+  SequenceManager,
   Store,
   StoreNotOpenError,
+  SubscriptionBloomFilter,
   SubscriptionManager,
+  TransactionContext,
   WorkerInitError,
   WorkerTimeoutError,
+  collectOperationsAheadOfServer,
+  compactOperationLog,
+  computeAckCompactionWatermark,
+  decodeAuditExport,
   decodeRichtext,
+  deserializeVersionVectorFromMeta,
   encodeRichtext,
+  exportBackup,
+  mergeVersionVectors,
+  persistedAuditTraceFromEvent,
   pluralize,
+  readAuditExportManifest,
+  readBackupManifest,
+  restoreBackup,
+  richtextStatesEqual,
   richtextToPlainText,
-  singularize
+  serializeVersionVectorToMeta,
+  singularize,
+  validateStateTransition,
+  validateUpdateStateMachine,
+  verifyAuditExportChecksum,
+  verifyBackupChecksum
 });
 //# sourceMappingURL=index.cjs.map