korajs 0.4.0 → 0.6.0

package/dist/index.cjs

@@ -30,33 +30,90 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  HybridLogicalClock: () => import_core3.HybridLogicalClock,
-  KoraError: () => import_core6.KoraError,
-  MergeEngine: () => import_merge2.MergeEngine,
-  SequenceManager: () => import_store2.SequenceManager,
-  Store: () => import_store2.Store,
-  SyncEngine: () => import_sync2.SyncEngine,
-  TransactionContext: () => import_store3.TransactionContext,
-  WebSocketTransport: () => import_sync2.WebSocketTransport,
+  AppNotReadyError: () => import_core10.AppNotReadyError,
+  HybridLogicalClock: () => import_core7.HybridLogicalClock,
+  KoraError: () => import_core10.KoraError,
+  MergeEngine: () => import_merge3.MergeEngine,
+  SequenceManager: () => import_store7.SequenceManager,
+  Store: () => import_store7.Store,
+  SyncEngine: () => import_sync7.SyncEngine,
+  TransactionContext: () => import_store8.TransactionContext,
+  WebSocketTransport: () => import_sync7.WebSocketTransport,
   createApp: () => createApp,
-  createOperation: () => import_core5.createOperation,
-  defineSchema: () => import_core2.defineSchema,
-  generateUUIDv7: () => import_core4.generateUUIDv7,
-  migrate: () => import_core2.migrate,
-  op: () => import_core7.op,
-  t: () => import_core2.t
+  createOperation: () => import_core9.createOperation,
+  decodeAuditExport: () => import_store6.decodeAuditExport,
+  defineSchema: () => import_core6.defineSchema,
+  exportBackup: () => import_store9.exportBackup,
+  generateUUIDv7: () => import_core8.generateUUIDv7,
+  migrate: () => import_core6.migrate,
+  op: () => import_core11.op,
+  readAuditExportManifest: () => import_store6.readAuditExportManifest,
+  readBackupManifest: () => import_store9.readBackupManifest,
+  restoreBackup: () => import_store9.restoreBackup,
+  t: () => import_core6.t,
+  verifyAuditExportChecksum: () => import_store6.verifyAuditExportChecksum,
+  verifyBackupChecksum: () => import_store9.verifyBackupChecksum
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/create-app.ts
+var import_internal5 = require("@korajs/core/internal");
+var import_merge2 = require("@korajs/merge");
+var import_store5 = require("@korajs/store");
+
+// src/collection-accessor.ts
 var import_core = require("@korajs/core");
-var import_internal = require("@korajs/core/internal");
-var import_devtools = require("@korajs/devtools");
-var import_merge = require("@korajs/merge");
-var import_store = require("@korajs/store");
-var import_sync = require("@korajs/sync");
+function createCollectionAccessor(collectionName, getStore) {
+  const notReady = (action) => new import_core.AppNotReadyError(
+    `Cannot ${action} on collection "${collectionName}" before app.ready. Await app.ready or use <KoraProvider app={app}>.`
+  );
+  return {
+    async insert(data) {
+      const currentStore = getStore();
+      if (!currentStore) {
+        throw notReady("insert into");
+      }
+      return currentStore.collection(collectionName).insert(data);
+    },
+    async findById(id) {
+      const currentStore = getStore();
+      if (!currentStore) return null;
+      return currentStore.collection(collectionName).findById(id);
+    },
+    async update(id, data) {
+      const currentStore = getStore();
+      if (!currentStore) {
+        throw notReady("update");
+      }
+      return currentStore.collection(collectionName).update(id, data);
+    },
+    async delete(id) {
+      const currentStore = getStore();
+      if (!currentStore) {
+        throw notReady("delete from");
+      }
+      return currentStore.collection(collectionName).delete(id);
+    },
+    where(conditions) {
+      const currentStore = getStore();
+      if (!currentStore) {
+        throw notReady("query");
+      }
+      return currentStore.collection(collectionName).where(conditions);
+    }
+  };
+}
+
+// src/initialize-app.ts
+var import_core4 = require("@korajs/core");
+var import_store4 = require("@korajs/store");
+var import_sync3 = require("@korajs/sync");
 
 // src/adapter-resolver.ts
+function importOptionalPeer(specifier) {
+  const dynamicImport = new Function("specifier", "return import(specifier)");
+  return dynamicImport(specifier);
+}
 function detectAdapterType() {
   if (typeof globalThis !== "undefined" && typeof globalThis.__TAURI_INTERNALS__ !== "undefined") {
     return "tauri-sqlite";
@@ -72,13 +129,10 @@ function detectAdapterType() {
   }
   return "better-sqlite3";
 }
-async function createAdapter(type, dbName, workerUrl) {
+async function createAdapter(type, dbName, workerUrl, emitter, workerResponseTimeoutMs, sharedWorkerUrl) {
   switch (type) {
     case "tauri-sqlite": {
-      const { TauriSqliteAdapter } = await import(
-        /* @vite-ignore */
-        "@korajs/tauri"
-      );
+      const { TauriSqliteAdapter } = await importOptionalPeer("@korajs/tauri");
       return new TauriSqliteAdapter({ path: `${dbName}.db` });
     }
     case "better-sqlite3": {
@@ -90,11 +144,11 @@ async function createAdapter(type, dbName, workerUrl) {
     }
     case "sqlite-wasm": {
       const { SqliteWasmAdapter } = await import("@korajs/store/sqlite-wasm");
-      return new SqliteWasmAdapter({ dbName, workerUrl });
+      return new SqliteWasmAdapter({ dbName, workerUrl, sharedWorkerUrl, workerResponseTimeoutMs });
     }
     case "indexeddb": {
       const { IndexedDbAdapter } = await import("@korajs/store/indexeddb");
-      return new IndexedDbAdapter({ dbName, workerUrl });
+      return new IndexedDbAdapter({ dbName, workerUrl, emitter, workerResponseTimeoutMs });
     }
     default: {
       const _exhaustive = type;
@@ -103,85 +157,525 @@ async function createAdapter(type, dbName, workerUrl) {
   }
 }
 
-// src/merge-aware-sync-store.ts
-var MergeAwareSyncStore = class {
-  constructor(store, mergeEngine, emitter) {
-    this.store = store;
-    this.mergeEngine = mergeEngine;
-    this.emitter = emitter;
+// src/apply-pipeline.ts
+var import_core3 = require("@korajs/core");
+var import_internal2 = require("@korajs/core/internal");
+var import_merge = require("@korajs/merge");
+var import_store = require("@korajs/store");
+var import_internal3 = require("@korajs/store/internal");
+
+// src/build-side-effect-entry.ts
+var import_core2 = require("@korajs/core");
+var import_internal = require("@korajs/store/internal");
+async function buildSideEffectEntry(ctx, effect, parentOpId, transactionId, mutationName) {
+  const causalDeps = [parentOpId];
+  const baseInput = {
+    nodeId: ctx.nodeId,
+    collection: effect.collection,
+    recordId: effect.recordId,
+    sequenceNumber: await ctx.allocateSequenceNumber(),
+    causalDeps,
+    schemaVersion: ctx.schema.version,
+    ...transactionId !== void 0 ? { transactionId } : {},
+    ...mutationName !== void 0 ? { mutationName } : {}
+  };
+  if (effect.type === "delete") {
+    const operation2 = await (0, import_core2.createOperation)(
+      {
+        ...baseInput,
+        type: "delete",
+        data: null,
+        previousData: effect.previousData
+      },
+      ctx.clock
+    );
+    ctx.causalTracker?.afterOperation(effect.collection, operation2.id, ctx.inTransaction);
+    const version2 = (0, import_internal.serializeRowVersion)(operation2.timestamp);
+    const deleteQuery = (0, import_internal.buildSoftDeleteQuery)(
+      effect.collection,
+      effect.recordId,
+      operation2.timestamp.wallTime,
+      version2
+    );
+    const opInsert2 = (0, import_internal.buildInsertQuery)(
+      `_kora_ops_${effect.collection}`,
+      (0, import_internal.serializeOperation)(operation2)
+    );
+    return {
+      operation: operation2,
+      collection: effect.collection,
+      commands: [
+        { sql: deleteQuery.sql, params: deleteQuery.params },
+        { sql: opInsert2.sql, params: opInsert2.params },
+        {
+          sql: "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
+          params: [ctx.nodeId, operation2.sequenceNumber]
+        }
+      ]
+    };
   }
-  store;
-  mergeEngine;
-  emitter;
-  getVersionVector() {
-    return this.store.getVersionVector();
+  const operation = await (0, import_core2.createOperation)(
+    {
+      ...baseInput,
+      type: "update",
+      data: effect.data,
+      previousData: effect.previousData
+    },
+    ctx.clock
+  );
+  ctx.causalTracker?.afterOperation(effect.collection, operation.id, ctx.inTransaction);
+  const definition = ctx.schema.collections[effect.collection];
+  const serializedChanges = effect.data && definition ? (0, import_internal.serializeRecord)(effect.data, definition.fields) : effect.data ?? {};
+  const version = (0, import_internal.serializeRowVersion)(operation.timestamp);
+  const updateQuery = (0, import_internal.buildUpdateQuery)(effect.collection, effect.recordId, {
+    ...serializedChanges,
+    _updated_at: operation.timestamp.wallTime,
+    _version: version
+  });
+  const opInsert = (0, import_internal.buildInsertQuery)(
+    `_kora_ops_${effect.collection}`,
+    (0, import_internal.serializeOperation)(operation)
+  );
+  return {
+    operation,
+    collection: effect.collection,
+    commands: [
+      { sql: updateQuery.sql, params: updateQuery.params },
+      { sql: opInsert.sql, params: opInsert.params },
+      {
+        sql: "INSERT OR REPLACE INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)",
+        params: [ctx.nodeId, operation.sequenceNumber]
+      }
+    ]
+  };
+}
+
+// src/apply-pipeline.ts
+var ApplyPipeline = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.relationLookupMap = (0, import_merge.buildMergeRelationLookup)(deps.store.getSchema());
   }
-  getNodeId() {
-    return this.store.getNodeId();
+  deps;
+  relationLookupMap;
+  /** Local insert — same persistence path as remote apply side effects. */
+  async insert(collection, data) {
+    return (0, import_internal3.executeInsert)(this.deps.store.createMutationContext(collection), data);
   }
-  async getOperationRange(nodeId, fromSeq, toSeq) {
-    return this.store.getOperationRange(nodeId, fromSeq, toSeq);
+  /** Local update. */
+  async update(collection, id, data) {
+    return (0, import_internal3.executeUpdate)(this.deps.store.createMutationContext(collection), id, data);
   }
-  async applyRemoteOperation(op2) {
-    if (op2.type !== "update" || !op2.data || !op2.previousData) {
-      return this.store.applyRemoteOperation(op2);
+  /**
+   * Local delete with merge-package referential integrity (same rules as remote delete).
+   */
+  async delete(collection, id) {
+    const ctx = this.deps.store.createMutationContext(collection);
+    const causalDeps = (0, import_internal3.resolveCausalDeps)(ctx);
+    const operation = await (0, import_core3.createOperation)(
+      {
+        nodeId: ctx.nodeId,
+        type: "delete",
+        collection,
+        recordId: id,
+        data: null,
+        previousData: null,
+        sequenceNumber: await ctx.allocateSequenceNumber(),
+        causalDeps,
+        schemaVersion: ctx.schema.version
+      },
+      ctx.clock
+    );
+    ctx.causalTracker?.afterOperation(collection, operation.id, ctx.inTransaction);
+    const refCtx = createReferentialMergeContext(this.deps.store);
+    const check = await (0, import_merge.checkReferentialIntegrityOnDelete)(
+      operation,
+      this.deps.store.getSchema(),
+      refCtx,
+      this.relationLookupMap
+    );
+    for (const trace of check.traces) {
+      this.deps.emitter?.emit({ type: "merge:conflict", trace });
+    }
+    if (!check.allowed) {
+      throw new import_core3.KoraError(
+        `Cannot delete record "${id}" from "${collection}": referential restrict policy violated`,
+        "REFERENTIAL_INTEGRITY",
+        { collection, recordId: id }
+      );
+    }
+    await (0, import_internal3.executeDelete)(ctx, id, {
+      skipReferentialEnforcement: true,
+      operation
+    });
+    if (check.sideEffectOps.length > 0) {
+      await applySideEffectOps(this.deps.store, check.sideEffectOps, operation.id);
+    }
+  }
+  /**
+   * Commit a buffered transaction: merge-package delete enforcement, causal ordering, single DB txn.
+   */
+  async commitTransaction(batch) {
+    const store = this.deps.store;
+    const supplemental = [];
+    for (const entry of batch.entries) {
+      if (entry.operation.type !== "delete") {
+        continue;
+      }
+      const refCtx = createReferentialMergeContext(store);
+      const check = await (0, import_merge.checkReferentialIntegrityOnDelete)(
+        entry.operation,
+        store.getSchema(),
+        refCtx,
+        this.relationLookupMap
+      );
+      for (const trace of check.traces) {
+        this.deps.emitter?.emit({ type: "merge:conflict", trace });
+      }
+      if (!check.allowed) {
+        throw new import_core3.KoraError(
+          `Cannot delete record "${entry.operation.recordId}" from "${entry.collection}": referential restrict policy violated`,
+          "REFERENTIAL_INTEGRITY",
+          { collection: entry.collection, recordId: entry.operation.recordId }
+        );
+      }
+      for (const effect of check.sideEffectOps) {
+        const ctx2 = store.createMutationContext(effect.collection, { inTransaction: true });
+        supplemental.push(
+          await buildSideEffectEntry(
+            ctx2,
+            effect,
+            entry.operation.id,
+            batch.transactionId,
+            batch.mutationName
+          )
+        );
+      }
+    }
+    const allEntries = [...batch.entries, ...supplemental];
+    const sortedOps = (0, import_internal2.topologicalSort)(allEntries.map((e) => e.operation));
+    const commandsByOpId = new Map(allEntries.map((e) => [e.operation.id, e.commands]));
+    const ctx = store.createMutationContext(
+      batch.entries[0]?.collection ?? Object.keys(store.getSchema().collections)[0] ?? "todos",
+      { inTransaction: true }
+    );
+    await ctx.adapter.transaction(async (tx) => {
+      for (const op2 of sortedOps) {
+        const commands = commandsByOpId.get(op2.id);
+        if (!commands) {
+          continue;
+        }
+        for (const cmd of commands) {
+          await tx.execute(cmd.sql, cmd.params);
+        }
+      }
+    });
+    const affectedCollections = /* @__PURE__ */ new Set();
+    for (const entry of allEntries) {
+      affectedCollections.add(entry.collection);
+    }
+    return { operations: sortedOps, affectedCollections };
+  }
+  async applyRemote(op2) {
+    return this.apply(op2, { mode: "remote", schema: this.deps.store.getSchema() });
+  }
+  async apply(op2, context) {
+    if (context.mode === "local") {
+      return this.deps.store.applyRemoteOperation(op2);
+    }
+    if (op2.type === "delete") {
+      return this.applyRemoteDelete(op2);
+    }
+    if (op2.type === "insert" && op2.data) {
+      return this.applyRemoteInsert(op2);
+    }
+    if (op2.type === "update" && op2.data && op2.previousData) {
+      return this.applyRemoteUpdate(op2);
+    }
+    return this.deps.store.applyRemoteOperation(op2);
+  }
+  async applyRemoteDelete(op2) {
+    const blocked = await this.resolveRemoteDeleteVsLocalUpdate(op2);
+    if (blocked) {
+      return "skipped";
+    }
+    const refCtx = createReferentialMergeContext(this.deps.store);
+    const check = await (0, import_merge.checkReferentialIntegrityOnDelete)(
+      op2,
+      this.deps.store.getSchema(),
+      refCtx,
+      this.relationLookupMap
+    );
+    for (const trace of check.traces) {
+      this.deps.emitter?.emit({ type: "merge:conflict", trace });
+    }
+    if (!check.allowed) {
+      return "rejected";
+    }
+    const result = await this.deps.store.applyRemoteOperation(op2);
+    if (result !== "applied") {
+      return result;
+    }
+    if (check.sideEffectOps.length > 0) {
+      await applySideEffectOps(this.deps.store, check.sideEffectOps, op2.id);
+    }
+    return "applied";
+  }
+  /**
+   * When a local update is newer than a remote delete, keep the record alive.
+   */
+  async resolveRemoteDeleteVsLocalUpdate(op2) {
+    const collectionDef = this.deps.store.getSchema().collections[op2.collection];
+    if (!collectionDef) {
+      return false;
+    }
+    const localOp = await this.deps.store.getLatestLocalOperationForRecord(
+      op2.collection,
+      op2.recordId
+    );
+    if (!localOp || localOp.type !== "update") {
+      return false;
     }
-    const schema = this.store.getSchema();
+    const baseState = localOp.previousData ?? {};
+    const mergeResult = await this.deps.mergeEngine.merge({
+      local: localOp,
+      remote: op2,
+      baseState,
+      collectionDef
+    });
+    this.emitMergeLifecycle(op2, localOp, mergeResult);
+    return mergeResult.appliedOperation === "local";
+  }
+  async applyRemoteUpdate(op2) {
+    const schema = this.deps.store.getSchema();
     const collectionDef = schema.collections[op2.collection];
     if (!collectionDef) {
-      return this.store.applyRemoteOperation(op2);
+      return this.deps.store.applyRemoteOperation(op2);
     }
-    const accessor = this.store.collection(op2.collection);
+    const accessor = this.deps.store.collection(op2.collection);
     const currentRecord = await accessor.findById(op2.recordId);
     if (!currentRecord) {
-      return this.store.applyRemoteOperation(op2);
+      const tombstoneResult = await this.applyRemoteUpdateOnDeletedRow(op2, collectionDef);
+      if (tombstoneResult !== null) {
+        return tombstoneResult;
+      }
+      return this.deps.store.applyRemoteOperation(op2);
     }
     let hasConflict = false;
-    for (const field of Object.keys(op2.data)) {
-      const expectedBase = op2.previousData[field];
+    for (const field of Object.keys(op2.data ?? {})) {
+      const fieldDef = collectionDef.fields[field];
+      const expectedBase = op2.previousData?.[field];
       const currentLocal = currentRecord[field];
+      if (fieldDef?.kind === "richtext") {
+        if (!(0, import_store.richtextStatesEqual)(currentLocal, expectedBase)) {
+          hasConflict = true;
+        }
+        continue;
+      }
       if (!deepEqual(expectedBase, currentLocal)) {
         hasConflict = true;
         break;
       }
     }
     if (!hasConflict) {
-      return this.store.applyRemoteOperation(op2);
+      return this.deps.store.applyRemoteOperation(op2);
     }
-    this.emitter?.emit({
-      type: "merge:started",
-      operationA: op2,
-      operationB: op2
+    return this.applyMergedUpdate(op2, collectionDef, currentRecord, op2.previousData ?? {});
+  }
+  /**
+   * Remote update vs local soft-delete: merge before materializing to avoid zombie rows.
+   */
+  async applyRemoteUpdateOnDeletedRow(op2, collectionDef) {
+    const snapshot = await this.deps.store.findMaterializedRow(op2.collection, op2.recordId);
+    if (!snapshot?.deleted) {
+      return null;
+    }
+    const localOp = await this.deps.store.getLatestLocalOperationForRecord(
+      op2.collection,
+      op2.recordId
+    );
+    if (!localOp || localOp.type !== "delete") {
+      return null;
+    }
+    const mergeResult = await this.deps.mergeEngine.merge({
+      local: localOp,
+      remote: op2,
+      baseState: op2.previousData ?? {},
+      collectionDef
+    });
+    this.emitMergeLifecycle(op2, localOp, mergeResult);
+    if (mergeResult.appliedOperation === "local") {
+      return "skipped";
+    }
+    const mergedOp = {
+      ...op2,
+      data: { ...mergeResult.mergedData },
+      timestamp: maxTimestamp(op2.timestamp, localOp.timestamp)
+    };
+    const applyResult = await this.deps.store.applyRemoteOperation(mergedOp, {
+      reactivateIfDeleted: true
     });
-    const baseState = { ...op2.previousData };
+    if (applyResult === "applied" && mergeResult.sideEffects.length > 0) {
+      await applySideEffectOps(this.deps.store, mergeResult.sideEffects, op2.id);
+    }
+    return applyResult;
+  }
+  async applyMergedUpdate(op2, collectionDef, currentRecord, baseState, applyOptions) {
+    const localTimestamp = await resolveLocalTimestamp(
+      this.deps.store,
+      op2.collection,
+      op2.recordId,
+      currentRecord,
+      this.deps.store.getNodeId()
+    );
     const localOp = {
       ...op2,
-      // The "local" operation's data is the diff between base and current local state
-      data: buildLocalDiff(op2.previousData, currentRecord, Object.keys(op2.data)),
+      data: buildLocalDiff(baseState, currentRecord, Object.keys(op2.data ?? {})),
       previousData: op2.previousData,
-      nodeId: this.store.getNodeId()
+      nodeId: this.deps.store.getNodeId(),
+      timestamp: localTimestamp
+    };
+    const constraintContext = createConstraintContext(this.deps.store);
+    const mergeResult = await this.deps.mergeEngine.merge(
+      {
+        local: localOp,
+        remote: op2,
+        baseState,
+        collectionDef
+      },
+      constraintContext
+    );
+    this.emitMergeLifecycle(op2, localOp, mergeResult);
+    const mergedOp = {
+      ...op2,
+      data: mergeResult.mergedData,
+      timestamp: maxTimestamp(op2.timestamp, localTimestamp)
     };
-    const input = {
+    const applyResult = await this.deps.store.applyRemoteOperation(mergedOp, applyOptions);
+    if (applyResult === "applied" && mergeResult.sideEffects.length > 0) {
+      await applySideEffectOps(this.deps.store, mergeResult.sideEffects, op2.id);
+    }
+    return applyResult;
+  }
+  async applyRemoteInsert(op2) {
+    const collectionDef = this.deps.store.getSchema().collections[op2.collection];
+    if (!collectionDef || !op2.data) {
+      return this.deps.store.applyRemoteOperation(op2);
+    }
+    const snapshot = await this.deps.store.findMaterializedRow(op2.collection, op2.recordId);
+    if (!snapshot || snapshot.deleted) {
+      return this.deps.store.applyRemoteOperation(op2);
+    }
+    const localOp = await resolveLocalOpForRecord(
+      this.deps.store,
+      op2.collection,
+      op2.recordId,
+      snapshot.record
+    );
+    const mergeResult = await this.deps.mergeEngine.merge({
       local: localOp,
       remote: op2,
-      baseState,
+      baseState: {},
       collectionDef
+    });
+    this.emitMergeLifecycle(op2, localOp, mergeResult);
+    const mergedOp = {
+      ...op2,
+      data: mergeResult.mergedData,
+      timestamp: maxTimestamp(op2.timestamp, localOp.timestamp)
     };
-    const result = this.mergeEngine.mergeFields(input);
-    for (const trace of result.traces) {
-      this.emitter?.emit({ type: "merge:conflict", trace });
+    return this.deps.store.applyRemoteOperation(mergedOp);
+  }
+  emitMergeLifecycle(remote, local, mergeResult) {
+    this.deps.emitter?.emit({
+      type: "merge:started",
+      operationA: remote,
+      operationB: local
+    });
+    const hadMergeConflict = mergeResult.traces.some(
+      (t2) => t2.strategy !== "no-conflict-local" && t2.strategy !== "no-conflict-remote" && t2.strategy !== "no-conflict-unchanged"
+    );
+    if (hadMergeConflict) {
+      this.deps.onMergeConflict?.();
+    }
+    for (const trace of mergeResult.traces) {
+      if (trace.strategy !== "no-conflict-local" && trace.strategy !== "no-conflict-remote" && trace.strategy !== "no-conflict-unchanged") {
+        this.deps.emitter?.emit({ type: "merge:conflict", trace });
+      }
     }
-    const firstTrace = result.traces[0];
+    const firstTrace = mergeResult.traces[0];
     if (firstTrace) {
-      this.emitter?.emit({ type: "merge:completed", trace: firstTrace });
+      this.deps.emitter?.emit({ type: "merge:completed", trace: firstTrace });
     }
-    const mergedOp = {
-      ...op2,
-      data: result.mergedData
-    };
-    return this.store.applyRemoteOperation(mergedOp);
   }
 };
+async function resolveLocalOpForRecord(store, collection, recordId, record) {
+  const localLatest = await store.getLatestLocalOperationForRecord(collection, recordId);
+  if (localLatest) {
+    return localLatest;
+  }
+  const anyLatest = await store.getLatestOperationForRecord(collection, recordId);
+  if (anyLatest) {
+    return anyLatest;
+  }
+  return syntheticInsertFromSnapshot(
+    record,
+    collection,
+    store.getNodeId(),
+    store.getSchema().version
+  );
+}
+function syntheticInsertFromSnapshot(record, collection, nodeId, schemaVersion) {
+  const { id, createdAt, updatedAt, ...fields } = record;
+  return {
+    id: `synthetic-local-${id}`,
+    nodeId,
+    type: "insert",
+    collection,
+    recordId: id,
+    data: fields,
+    previousData: null,
+    timestamp: { wallTime: updatedAt, logical: 0, nodeId },
+    sequenceNumber: 0,
+    causalDeps: [],
+    schemaVersion
+  };
+}
+function createConstraintContext(store) {
+  return {
+    async queryRecords(collection, where) {
+      const rows = await store.collection(collection).where(where).exec();
+      return rows;
+    },
+    async countRecords(collection, where) {
+      return store.collection(collection).where(where).count();
+    }
+  };
+}
+function createReferentialMergeContext(store) {
+  return {
+    async queryRecords(collection, where) {
+      const rows = await store.collection(collection).where(where).exec();
+      return rows;
+    },
+    async recordExists(collection, recordId) {
+      const row = await store.collection(collection).findById(recordId);
+      return row !== null;
+    }
+  };
+}
+async function applySideEffectOps(store, sideEffects, parentOpId) {
+  for (const effect of sideEffects) {
+    const ctx = store.createMutationContext(effect.collection, {
+      extraCausalDeps: [parentOpId]
+    });
+    if (effect.type === "delete") {
+      await (0, import_internal3.executeDelete)(ctx, effect.recordId, { skipReferentialEnforcement: true });
+    } else if (effect.type === "update" && effect.data) {
+      await (0, import_internal3.executeUpdate)(ctx, effect.recordId, effect.data);
+    }
+  }
+}
 function buildLocalDiff(baseState, currentRecord, fields) {
   const diff = {};
   for (const field of fields) {
@@ -189,6 +683,20 @@ function buildLocalDiff(baseState, currentRecord, fields) {
   }
   return diff;
 }
+async function resolveLocalTimestamp(store, collection, recordId, currentRecord, nodeId) {
+  const latestLocal = await store.getLatestLocalOperationForRecord(collection, recordId);
+  if (latestLocal) {
+    return latestLocal.timestamp;
+  }
+  const updatedAt = currentRecord.updatedAt;
+  if (typeof updatedAt === "number") {
+    return { wallTime: updatedAt, logical: 0, nodeId };
+  }
+  return { wallTime: Date.now(), logical: 0, nodeId };
+}
+function maxTimestamp(a, b) {
+  return import_core3.HybridLogicalClock.compare(a, b) >= 0 ? a : b;
+}
 function deepEqual(a, b) {
   if (a === b) return true;
   if (a === null || b === null) return false;
@@ -209,113 +717,371 @@ function deepEqual(a, b) {
   return false;
 }
 
-// src/create-app.ts
-function createApp(config) {
-  const emitter = new import_internal.SimpleEventEmitter();
-  const mergeEngine = new import_merge.MergeEngine();
-  let store = null;
-  let syncEngine = null;
-  let unsubscribeSync = null;
-  let reconnectionManager = null;
-  let connectionMonitor = null;
-  let instrumenter = null;
-  let intentionalDisconnect = false;
-  let qualityInterval = null;
-  if (config.devtools) {
-    instrumenter = new import_devtools.Instrumenter(emitter, {
-      bridgeEnabled: typeof globalThis !== "undefined" && "window" in globalThis
+// src/audit-bridge.ts
+var import_store2 = require("@korajs/store");
+var AUDIT_EVENT_TYPES = ["merge:completed", "merge:conflict", "constraint:violated"];
+function isAuditEvent(event) {
+  return AUDIT_EVENT_TYPES.includes(event.type);
+}
+function wireAuditPersistence(store, emitter) {
+  const unsubscribers = AUDIT_EVENT_TYPES.map(
+    (eventType) => emitter.on(eventType, (event) => {
+      if (!isAuditEvent(event)) {
+        return;
+      }
+      const trace = (0, import_store2.persistedAuditTraceFromEvent)(event);
+      void store.appendAuditTrace(trace).catch(() => {
+      });
+    })
+  );
+  return () => {
+    for (const unsub of unsubscribers) {
+      unsub();
+    }
+  };
+}
+
+// src/create-sync-transport.ts
+var import_sync = require("@korajs/sync");
+function createSyncTransport(sync) {
+  if (sync.transport === "http") {
+    return new import_sync.HttpLongPollingTransport();
+  }
+  return new import_sync.WebSocketTransport();
+}
+
+// src/merge-aware-sync-store.ts
+var MergeAwareSyncStore = class {
+  constructor(store, mergeEngine, emitter, options) {
+    this.store = store;
+    this.pipeline = new ApplyPipeline({
+      store,
+      mergeEngine,
+      emitter,
+      onMergeConflict: options?.onMergeConflict
     });
   }
-  const ready = initializeAsync(config, emitter, mergeEngine).then((result) => {
-    store = result.store;
-    syncEngine = result.syncEngine;
-    unsubscribeSync = result.unsubscribeSync;
-    if (config.sync && syncEngine) {
-      connectionMonitor = new import_sync.ConnectionMonitor();
-      reconnectionManager = new import_sync.ReconnectionManager({
-        initialDelay: config.sync.reconnectInterval,
-        maxDelay: config.sync.maxReconnectInterval
-      });
-      emitter.on("sync:sent", () => connectionMonitor?.recordActivity());
-      emitter.on("sync:received", () => connectionMonitor?.recordActivity());
-      emitter.on("sync:acknowledged", () => connectionMonitor?.recordActivity());
-      emitter.on("sync:connected", () => {
-        if (qualityInterval !== null) clearInterval(qualityInterval);
-        qualityInterval = setInterval(() => {
-          if (connectionMonitor) {
-            emitter.emit({ type: "connection:quality", quality: connectionMonitor.getQuality() });
-          }
-        }, 5e3);
-      });
-      emitter.on("sync:disconnected", () => {
-        connectionMonitor?.reset();
-        if (qualityInterval !== null) {
-          clearInterval(qualityInterval);
-          qualityInterval = null;
-        }
-      });
-      if (config.sync.autoReconnect !== false) {
-        const engine = syncEngine;
-        emitter.on("sync:disconnected", () => {
-          if (intentionalDisconnect) return;
-          if (reconnectionManager?.isRunning()) return;
-          engine.setReconnecting(true);
-          reconnectionManager?.stop();
-          reconnectionManager?.start(async () => {
-            try {
-              await engine.start();
-              engine.setReconnecting(false);
-              return true;
-            } catch {
-              return false;
-            }
-          }).then(() => {
-            engine.setReconnecting(false);
-          });
-        });
-      }
+  store;
+  pipeline;
+  getVersionVector() {
+    return this.store.getVersionVector();
+  }
+  getNodeId() {
+    return this.store.getNodeId();
+  }
+  async getOperationRange(nodeId, fromSeq, toSeq) {
+    return this.store.getOperationRange(nodeId, fromSeq, toSeq);
+  }
+  async applyRemoteOperation(op2) {
+    return this.pipeline.applyRemote(op2);
+  }
+};
+
+// src/store-queue-storage.ts
+var import_internal4 = require("@korajs/store/internal");
+var StoreQueueStorage = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  adapter;
+  async load() {
+    const rows = await this.adapter.query(
+      "SELECT id, payload FROM _kora_sync_queue ORDER BY rowid ASC"
+    );
+    return rows.map((row) => operationFromQueuePayload(row.payload));
+  }
+  async enqueue(op2) {
+    const row = (0, import_internal4.serializeOperation)(op2);
+    const payload = { ...row, _collection: op2.collection };
+    await this.adapter.execute(
+      "INSERT OR REPLACE INTO _kora_sync_queue (id, payload) VALUES (?, ?)",
+      [op2.id, JSON.stringify(payload)]
+    );
+  }
+  async dequeue(ids) {
+    if (ids.length === 0) return;
+    const placeholders = ids.map(() => "?").join(", ");
+    await this.adapter.execute(`DELETE FROM _kora_sync_queue WHERE id IN (${placeholders})`, ids);
+  }
+  async count() {
+    const rows = await this.adapter.query(
+      "SELECT COUNT(*) as cnt FROM _kora_sync_queue"
+    );
+    return rows[0]?.cnt ?? 0;
+  }
+};
+function operationFromQueuePayload(payload) {
+  const parsed = JSON.parse(payload);
+  const op2 = (0, import_internal4.deserializeOperation)(parsed);
+  return {
+    ...op2,
+    collection: parsed._collection
+  };
+}
+
+// src/store-sync-state.ts
+var import_store3 = require("@korajs/store");
+var import_sync2 = require("@korajs/sync");
+var StoreSyncStatePersistence = class {
+  constructor(store, scope) {
+    this.store = store;
+    this.scope = scope;
+  }
+  store;
+  scope;
+  loadLastAckedServerVector() {
+    return this.store.loadLastAckedServerVector();
+  }
+  saveLastAckedServerVector(vector) {
+    return this.store.saveLastAckedServerVector(vector);
+  }
+  mergeServerVectors(a, b) {
+    return this.store.mergeServerVectors(a, b);
+  }
+  async countUnsyncedOperations(serverVector) {
+    const ops = await this.getUnsyncedOperations(serverVector);
+    return ops.length;
+  }
+  async getUnsyncedOperations(serverVector) {
+    const ops = await this.store.getUnsyncedOperations(serverVector);
+    return ops.filter((op2) => (0, import_sync2.operationMatchesScope)(op2, this.scope));
+  }
+  loadDeltaCursor() {
+    return this.store.loadDeltaCursor().then((encoded) => (0, import_sync2.decodeDeltaCursor)(encoded));
+  }
+  async saveDeltaCursor(cursor) {
+    await this.store.saveDeltaCursor(cursor ? (0, import_sync2.encodeDeltaCursor)(cursor) : null);
+  }
+};
+
+// src/sync-query-bridge.ts
+function queryDescriptorToSyncSubset(descriptor) {
+  const where = {};
+  const skippedFields = [];
+  for (const [field, value] of Object.entries(descriptor.where)) {
+    if (value === null || value === void 0) {
+      where[field] = value;
+      continue;
     }
-  });
-  const syncControl = config.sync ? {
-    async connect() {
-      await ready;
-      if (syncEngine) {
-        intentionalDisconnect = false;
-        reconnectionManager?.stop();
-        reconnectionManager?.reset();
-        await syncEngine.start();
-      }
+    if (typeof value !== "object" || Array.isArray(value)) {
+      where[field] = value;
+      continue;
+    }
+    skippedFields.push(field);
+  }
+  if (skippedFields.length > 0 && typeof console !== "undefined") {
+    console.warn(
+      `[Kora] Sync query subset omitted non-equality filters on ${descriptor.collection}: ${skippedFields.join(", ")}. Only plain equality WHERE clauses are registered for incremental sync.`
+    );
+  }
+  if (Object.keys(where).length === 0) {
+    return null;
+  }
+  return {
+    collection: descriptor.collection,
+    where
+  };
+}
+function createSyncQuerySubscriptionHook(getSyncEngine) {
+  return (descriptor) => {
+    const subset = queryDescriptorToSyncSubset(descriptor);
+    if (!subset) {
+      return () => {
+      };
+    }
+    const engine = getSyncEngine();
+    if (!engine) {
+      return () => {
+      };
+    }
+    return engine.registerQuerySubset(subset);
+  };
+}
+
+// src/initialize-app.ts
+async function initializeApp(config, emitter, mergeEngine) {
+  const adapterType = config.store?.adapter ?? detectAdapterType();
+  const dbName = config.store?.name ?? "kora-db";
+  const adapter = await createAdapter(
+    adapterType,
+    dbName,
+    config.store?.workerUrl,
+    emitter,
+    config.store?.workerResponseTimeoutMs,
+    config.store?.sharedWorkerUrl
+  );
+  const authBinding = config.sync?.authClient ?? null;
+  const authNodeId = authBinding?.resolveNodeId ? await authBinding.resolveNodeId() : void 0;
+  let syncEngine = null;
+  const store = new import_store4.Store({
+    schema: config.schema,
+    adapter,
+    emitter,
+    dbName,
+    nodeId: authNodeId,
+    isolation: authNodeId ? "shared" : config.store?.isolation,
+    ...config.sync ? { onQuerySubscribed: createSyncQuerySubscriptionHook(() => syncEngine) } : {}
+  });
+  await store.open();
+  let recordConflict;
+  const applyPipeline = new ApplyPipeline({
+    store,
+    mergeEngine,
+    emitter,
+    onMergeConflict: () => recordConflict?.()
+  });
+  store.setLocalMutationHandler(applyPipeline);
+  const unsubscribeAudit = wireAuditPersistence(store, emitter);
+  let unsubscribeSync = null;
+  if (config.sync) {
+    const transport = createSyncTransport(config.sync);
+    const mergeAwareStore = new MergeAwareSyncStore(store, mergeEngine, emitter, {
+      onMergeConflict: () => recordConflict?.()
+    });
+    let scopeMap = config.sync.scope ? (0, import_core4.buildScopeMap)(config.schema, config.sync.scope) : void 0;
+    if (authBinding?.resolveScopeMap) {
+      scopeMap = await authBinding.resolveScopeMap() ?? scopeMap;
+    }
+    const syncAuth = authBinding?.auth ?? config.sync.auth;
+    const encryptor = config.sync.encryption?.enabled === true ? await import_sync3.SyncEncryptor.create(config.sync.encryption) : void 0;
+    syncEngine = new import_sync3.SyncEngine({
+      transport,
+      store: mergeAwareStore,
+      config: {
+        url: config.sync.url,
+        transport: config.sync.transport,
+        auth: syncAuth,
+        batchSize: config.sync.batchSize,
+        schemaVersion: config.sync.schemaVersion ?? config.schema.version,
+        scopeMap,
+        encryption: config.sync.encryption,
+        strictHandshake: config.sync.strictHandshake,
+        operationTransforms: config.sync.operationTransforms
+      },
+      emitter,
+      queueStorage: new StoreQueueStorage(adapter),
+      syncState: new StoreSyncStatePersistence(store, scopeMap),
+      encryptor
+    });
+    recordConflict = () => syncEngine?.recordConflict();
+    unsubscribeSync = emitter.on("operation:created", (event) => {
+      if (syncEngine) {
+        syncEngine.pushOperation(event.operation);
+      }
+    });
+  }
+  return {
+    store,
+    syncEngine,
+    unsubscribeSync,
+    unsubscribeAudit,
+    authBinding
+  };
+}
+
+// src/sequences-accessor.ts
+function createSequencesAccessor(ready, getStore) {
+  const requireStore = async () => {
+    await ready;
+    const store = getStore();
+    if (!store) {
+      throw new Error("Store not initialized. Await app.ready before using sequences.");
+    }
+    return store;
+  };
+  return {
+    async next(name, config) {
+      const store = await requireStore();
+      return store.getSequenceManager().next(name, config);
+    },
+    async current(name, config) {
+      const store = await requireStore();
+      return store.getSequenceManager().current(name, config);
+    },
+    async reset(name, config) {
+      const store = await requireStore();
+      return store.getSequenceManager().reset(name, config);
+    }
+  };
+}
+
+// src/setup-devtools.ts
+var import_devtools = require("@korajs/devtools");
+function setupDevtools(config, emitter) {
+  if (!config.devtools) {
+    return { instrumenter: null, destroyOverlay: null };
+  }
+  const instrumenter = new import_devtools.Instrumenter(emitter, {
+    bridgeEnabled: typeof globalThis !== "undefined" && "window" in globalThis
+  });
+  let destroyOverlay = null;
+  if (typeof globalThis !== "undefined" && "window" in globalThis) {
+    void import("@korajs/devtools/overlay").then(({ mountKoraDevtoolsOverlay }) => {
+      destroyOverlay = mountKoraDevtoolsOverlay(instrumenter);
+    }).catch(() => {
+    });
+  }
+  return { instrumenter, destroyOverlay: () => destroyOverlay?.() };
+}
+
+// src/sync-control.ts
+var import_sync4 = require("@korajs/sync");
+function createSyncControl(options) {
+  const { config, ready, state } = options;
+  if (!config.sync) {
+    return null;
+  }
+  const offlineSyncStatus = () => import_sync4.OFFLINE_SYNC_STATUS;
+  const bridgeStatus = () => state.syncStatusBridge?.status ?? offlineSyncStatus();
+  return {
+    get status() {
+      return bridgeStatus();
+    },
+    subscribeStatus(listener) {
+      if (state.syncStatusBridge) {
+        return state.syncStatusBridge.subscribe(listener);
+      }
+      listener(offlineSyncStatus());
+      return () => {
+      };
+    },
+    async connect() {
+      await ready;
+      if (state.syncEngine) {
+        state.intentionalDisconnect = false;
+        state.reconnectionManager?.stop();
+        state.reconnectionManager?.reset();
+        await state.syncEngine.start();
+        state.syncStatusBridge?.refresh();
+      }
     },
     async disconnect() {
       await ready;
-      if (syncEngine) {
-        intentionalDisconnect = true;
-        reconnectionManager?.stop();
-        await syncEngine.stop();
+      if (state.syncEngine) {
+        state.intentionalDisconnect = true;
+        state.reconnectionManager?.stop();
+        await state.syncEngine.stop();
+        state.syncStatusBridge?.refresh();
       }
     },
     getStatus() {
-      if (syncEngine) {
-        return syncEngine.getStatus();
+      if (state.syncEngine) {
+        return state.syncEngine.getStatus();
       }
-      return {
-        status: "offline",
-        pendingOperations: 0,
-        lastSyncedAt: null,
-        lastSuccessfulPush: null,
-        lastSuccessfulPull: null,
-        conflicts: 0
-      };
+      return offlineSyncStatus();
     },
     async retryNow() {
       await ready;
-      if (syncEngine) {
-        await syncEngine.retryNow();
+      if (state.syncEngine) {
+        await state.syncEngine.retryNow();
       }
     },
+    clearSchemaBlock() {
+      state.syncEngine?.clearSchemaBlock();
+    },
     exportDiagnostics() {
-      if (syncEngine) {
-        return syncEngine.exportDiagnostics();
+      if (state.syncEngine) {
+        return state.syncEngine.exportDiagnostics();
       }
       return {
         state: "disconnected",
@@ -340,62 +1106,341 @@ function createApp(config) {
         timestamp: Date.now()
       };
     }
-  } : null;
-  async function executeTransaction(fn, mutationName) {
+  };
+}
+
+// src/auth-sync-coordinator.ts
+var AuthSyncCoordinator = class {
+  constructor(getEngine, authBinding) {
+    this.getEngine = getEngine;
+    this.authBinding = authBinding;
+  }
+  getEngine;
+  authBinding;
+  inFlight = null;
+  pending = false;
+  disposed = false;
+  scheduleReconnect() {
+    if (this.disposed) {
+      return;
+    }
+    if (this.inFlight) {
+      this.pending = true;
+      return;
+    }
+    this.inFlight = this.run().finally(() => {
+      this.inFlight = null;
+      if (this.pending && !this.disposed) {
+        this.pending = false;
+        this.scheduleReconnect();
+      }
+    });
+  }
+  destroy() {
+    this.disposed = true;
+    this.pending = false;
+  }
+  async run() {
+    const engine = this.getEngine();
+    if (!engine) {
+      return;
+    }
+    const headers = await this.authBinding.auth();
+    if (!headers.token) {
+      await engine.stop();
+      return;
+    }
+    if (this.authBinding.resolveScopeMap) {
+      const nextScope = await this.authBinding.resolveScopeMap();
+      engine.updateScope(nextScope);
+    }
+    const status = engine.getStatus().status;
+    if (status !== "offline") {
+      await engine.stop();
+    }
+    await engine.start();
+  }
+};
+
+// src/sync-status-bridge.ts
+var import_sync5 = require("@korajs/sync");
+function createSyncStatusBridge(emitter, getSyncEngine) {
+  const controller = (0, import_sync5.createSyncStatusController)({
+    getSyncEngine,
+    subscribeSyncStatus: null,
+    events: emitter
+  });
+  return {
+    get status() {
+      return controller.getSnapshot();
+    },
+    subscribe(listener) {
+      return controller.subscribe(() => {
+        listener(controller.getSnapshot());
+      });
+    },
+    refresh: () => controller.refresh(),
+    destroy: () => controller.destroy()
+  };
+}
+
+// src/sync-lifecycle.ts
+var import_sync6 = require("@korajs/sync");
+function wireSyncLifecycleAfterReady(config, emitter, state, init) {
+  state.syncEngine = init.syncEngine;
+  if (!config.sync) {
+    return;
+  }
+  state.syncStatusBridge = createSyncStatusBridge(emitter, () => state.syncEngine);
+  state.syncStatusBridge.refresh();
+  if (state.syncEngine && init.authBinding?.subscribe) {
+    state.authSyncCoordinator = new AuthSyncCoordinator(() => state.syncEngine, init.authBinding);
+    init.authBinding.subscribe(() => {
+      state.authSyncCoordinator?.scheduleReconnect();
+    });
+  }
+  if (!state.syncEngine) {
+    return;
+  }
+  const syncEngine = state.syncEngine;
+  state.connectionMonitor = new import_sync6.ConnectionMonitor();
+  state.reconnectionManager = new import_sync6.ReconnectionManager({
+    initialDelay: config.sync.reconnectInterval,
+    maxDelay: config.sync.maxReconnectInterval
+  });
+  emitter.on("sync:sent", () => state.connectionMonitor?.recordActivity());
+  emitter.on("sync:received", () => state.connectionMonitor?.recordActivity());
+  emitter.on("sync:acknowledged", () => state.connectionMonitor?.recordActivity());
+  emitter.on("sync:connected", () => {
+    if (state.qualityInterval !== null) {
+      clearInterval(state.qualityInterval);
+    }
+    state.qualityInterval = setInterval(() => {
+      if (state.connectionMonitor) {
+        emitter.emit({
+          type: "connection:quality",
+          quality: state.connectionMonitor.getQuality()
+        });
+      }
+    }, 5e3);
+  });
+  emitter.on("sync:disconnected", () => {
+    state.connectionMonitor?.reset();
+    if (state.qualityInterval !== null) {
+      clearInterval(state.qualityInterval);
+      state.qualityInterval = null;
+    }
+  });
+  const browserGlobal = globalThis;
+  if (typeof browserGlobal.addEventListener === "function") {
+    const onOnline = () => {
+      if (state.intentionalDisconnect || config.sync?.autoReconnect === false) {
+        return;
+      }
+      state.reconnectionManager?.wake();
+      state.reconnectionManager?.reset();
+      void syncEngine.retryNow();
+    };
+    browserGlobal.addEventListener("online", onOnline);
+    state.removeOnlineListener = () => {
+      browserGlobal.removeEventListener?.("online", onOnline);
+    };
+  }
+  emitter.on("sync:schema-mismatch", () => {
+    state.reconnectionManager?.stop();
+    state.intentionalDisconnect = true;
+  });
+  if (config.sync.autoReconnect !== false) {
+    emitter.on("sync:disconnected", () => {
+      if (state.intentionalDisconnect || syncEngine.isSchemaBlocked()) {
+        return;
+      }
+      if (state.reconnectionManager?.isRunning()) {
+        return;
+      }
+      syncEngine.setReconnecting(true);
+      state.reconnectionManager?.stop();
+      state.reconnectionManager?.start(async () => {
+        try {
+          await syncEngine.start();
+          syncEngine.setReconnecting(false);
+          return true;
+        } catch {
+          return false;
+        }
+      }).then(() => {
+        syncEngine.setReconnecting(false);
+      });
+    });
+  }
+  if (config.sync.autoConnect === true) {
+    void syncEngine.start().catch(() => {
+    });
+  }
+}
+function teardownSyncLifecycle(state) {
+  if (state.qualityInterval !== null) {
+    clearInterval(state.qualityInterval);
+    state.qualityInterval = null;
+  }
+  state.reconnectionManager?.stop();
+  state.syncStatusBridge?.destroy();
+  state.syncStatusBridge = null;
+  state.authSyncCoordinator?.destroy();
+  state.authSyncCoordinator = null;
+  state.removeOnlineListener?.();
+  state.removeOnlineListener = null;
+}
+
+// src/transaction-executor.ts
+function createTransactionExecutor(config, ready, getStore) {
+  return async (fn, mutationName) => {
     await ready;
+    const store = getStore();
     if (!store) {
       throw new Error("Store not initialized. Await app.ready before using transactions.");
     }
-    const txContext = store.createTransaction();
-    if (mutationName !== void 0) {
-      txContext.setMutationName(mutationName);
-    }
     const collectionNames = Object.keys(config.schema.collections);
-    const proxy = {};
-    for (const name of collectionNames) {
-      Object.defineProperty(proxy, name, {
-        get() {
-          return txContext.collection(name);
-        },
-        enumerable: true,
-        configurable: false
-      });
-    }
-    try {
+    return store.transaction(async (tx) => {
+      if (mutationName !== void 0) {
+        tx.setMutationName(mutationName);
+      }
+      const proxy = {};
+      for (const name of collectionNames) {
+        Object.defineProperty(proxy, name, {
+          get() {
+            return tx.collection(name);
+          },
+          enumerable: true,
+          configurable: false
+        });
+      }
       await fn(proxy);
-      const { operations } = await txContext.commit();
-      for (const op2 of operations) {
-        store.getSubscriptionManager().notify(op2.collection, op2);
-        emitter.emit({ type: "operation:created", operation: op2 });
+    });
+  };
+}
+
+// src/validate-config.ts
+var import_core5 = require("@korajs/core");
+function validateCreateAppConfig(config) {
+  if (!config.schema) {
+    throw new import_core5.SchemaValidationError("createApp requires a schema.", {
+      fix: "Pass schema: defineSchema({ version: 1, collections: { ... } })"
+    });
+  }
+  if (config.schema.version < 1) {
+    throw new import_core5.SchemaValidationError("Schema version must be at least 1.", {
+      version: config.schema.version
+    });
+  }
+  const collectionNames = Object.keys(config.schema.collections);
+  if (collectionNames.length === 0) {
+    throw new import_core5.SchemaValidationError("Schema must define at least one collection.", {
+      fix: "Add entries under collections in defineSchema()."
+    });
+  }
+  if (config.sync) {
+    validateSyncUrl(config.sync.url, config.sync.transport ?? "websocket");
+  }
+  const adapter = config.store?.adapter ?? detectAdapterType();
+  const isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+  if (isBrowser && (adapter === "sqlite-wasm" || adapter === "indexeddb") && !config.store?.workerUrl) {
+    throw new import_core5.KoraError(
+      "Browser storage requires store.workerUrl pointing to the SQLite WASM worker script.",
+      "MISSING_WORKER_URL",
+      {
+        adapter,
+        fix: 'Add store: { workerUrl: "/sqlite-wasm-worker.js" } (see create-kora-app templates).'
       }
-      return operations;
-    } catch (error) {
-      txContext.rollback();
-      throw error;
-    }
+    );
   }
-  const sequences = {
-    async next(name, config2) {
-      await ready;
-      if (!store) throw new Error("Store not initialized. Await app.ready before using sequences.");
-      return store.getSequenceManager().next(name, config2);
-    },
-    async current(name, config2) {
-      await ready;
-      if (!store) throw new Error("Store not initialized. Await app.ready before using sequences.");
-      return store.getSequenceManager().current(name, config2);
-    },
-    async reset(name, config2) {
-      await ready;
-      if (!store) throw new Error("Store not initialized. Await app.ready before using sequences.");
-      return store.getSequenceManager().reset(name, config2);
+}
+function validateSyncUrl(url, transport) {
+  if (!url || url.trim().length === 0) {
+    throw new import_core5.KoraError("sync.url is required when sync is configured.", "INVALID_SYNC_URL", {
+      fix: 'Pass sync: { url: "wss://your-server/kora" }.'
+    });
+  }
+  try {
+    const parsed = new URL(url);
+    if (transport === "http") {
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("bad protocol");
+      }
+    } else if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+      throw new Error("bad protocol");
     }
+  } catch {
+    throw new import_core5.KoraError(
+      `Invalid sync URL "${url}" for transport "${transport}".`,
+      "INVALID_SYNC_URL",
+      {
+        url,
+        transport,
+        fix: transport === "http" ? "Use an absolute http:// or https:// URL." : "Use an absolute ws:// or wss:// URL."
+      }
+    );
+  }
+}
+
+// src/wire-sync-event-forwarding.ts
+var SYNC_EVENT_TYPES = [
+  "sync:connected",
+  "sync:disconnected",
+  "sync:schema-mismatch",
+  "sync:auth-failed",
+  "sync:sent",
+  "sync:received",
+  "sync:acknowledged",
+  "sync:apply-failed",
+  "sync:diagnostics",
+  "sync:bandwidth",
+  "sync:initial-sync-progress"
+];
+function wireSyncEventForwarding(emitter, handler) {
+  for (const type of SYNC_EVENT_TYPES) {
+    emitter.on(type, (event) => {
+      handler(event);
+    });
+  }
+}
+
+// src/create-app.ts
+function createApp(config) {
+  validateCreateAppConfig(config);
+  const emitter = new import_internal5.SimpleEventEmitter();
+  const mergeEngine = new import_merge2.MergeEngine();
+  if (config.onSyncEvent) {
+    wireSyncEventForwarding(emitter, config.onSyncEvent);
+  }
+  let store = null;
+  let unsubscribeSync = null;
+  let unsubscribeAudit = null;
+  const syncState = {
+    syncEngine: null,
+    syncStatusBridge: null,
+    authSyncCoordinator: null,
+    reconnectionManager: null,
+    connectionMonitor: null,
+    qualityInterval: null,
+    intentionalDisconnect: false,
+    removeOnlineListener: null
   };
+  const devtools = setupDevtools(config, emitter);
+  const queryStoreCache = new import_store5.QueryStoreCache(config.store?.name ?? "kora-db");
+  const ready = initializeApp(config, emitter, mergeEngine).then((init) => {
+    store = init.store;
+    unsubscribeSync = init.unsubscribeSync;
+    unsubscribeAudit = init.unsubscribeAudit;
+    wireSyncLifecycleAfterReady(config, emitter, syncState, init);
+  });
+  const getStore = () => store;
+  const executeTransaction = createTransactionExecutor(config, ready, getStore);
   const app = {
     ready,
     events: emitter,
-    sync: syncControl,
-    sequences,
+    sync: createSyncControl({ config, ready, state: syncState }),
+    sequences: createSequencesAccessor(ready, getStore),
     getStore() {
       if (!store) {
         throw new Error("Store not initialized. Await app.ready before accessing the store.");
@@ -403,45 +1448,75 @@ function createApp(config) {
       return store;
     },
     getSyncEngine() {
-      return syncEngine;
+      return syncState.syncEngine;
+    },
+    getQueryStoreCache() {
+      return queryStoreCache;
     },
-    async transaction(fn) {
+    transaction(fn) {
       return executeTransaction(fn);
     },
-    async mutation(name, fn) {
+    mutation(name, fn) {
       return executeTransaction(fn, name);
     },
     async close() {
       await ready;
-      intentionalDisconnect = true;
-      if (qualityInterval !== null) {
-        clearInterval(qualityInterval);
-        qualityInterval = null;
-      }
-      reconnectionManager?.stop();
-      if (instrumenter) {
-        instrumenter.destroy();
-        instrumenter = null;
-      }
+      syncState.intentionalDisconnect = true;
+      teardownSyncLifecycle(syncState);
+      devtools.destroyOverlay?.();
+      devtools.instrumenter?.destroy();
       if (unsubscribeSync) {
         unsubscribeSync();
         unsubscribeSync = null;
       }
-      if (syncEngine) {
-        await syncEngine.stop();
-        syncEngine = null;
+      if (unsubscribeAudit) {
+        unsubscribeAudit();
+        unsubscribeAudit = null;
+      }
+      if (syncState.syncEngine) {
+        await syncState.syncEngine.stop();
+        syncState.syncEngine = null;
       }
+      queryStoreCache.clear();
       if (store) {
         await store.close();
         store = null;
       }
       emitter.clear();
+    },
+    async exportBackup(options) {
+      await ready;
+      if (!store) {
+        throw new Error("Store not initialized. Await app.ready before exporting backup.");
+      }
+      return store.exportBackup(options);
+    },
+    async importBackup(data, options) {
+      await ready;
+      if (!store) {
+        throw new Error("Store not initialized. Await app.ready before importing backup.");
+      }
+      return store.importBackup(data, options);
+    },
+    async replayTo(operationId) {
+      await ready;
+      if (!store) {
+        throw new Error("Store not initialized. Await app.ready before replaying operations.");
+      }
+      return store.replayTo(operationId);
+    },
+    async exportAudit(options) {
+      await ready;
+      if (!store) {
+        throw new Error("Store not initialized. Await app.ready before exporting audit data.");
+      }
+      return store.exportAudit(options);
     }
   };
   for (const collectionName of Object.keys(config.schema.collections)) {
     Object.defineProperty(app, collectionName, {
       get() {
-        return createCollectionAccessor(collectionName, () => store);
+        return createCollectionAccessor(collectionName, getStore);
       },
       enumerable: true,
       configurable: false
@@ -449,136 +1524,23 @@ function createApp(config) {
   }
   return app;
 }
-async function initializeAsync(config, emitter, mergeEngine) {
-  const adapterType = config.store?.adapter ?? detectAdapterType();
-  const dbName = config.store?.name ?? "kora-db";
-  const adapter = await createAdapter(adapterType, dbName, config.store?.workerUrl);
-  const store = new import_store.Store({
-    schema: config.schema,
-    adapter,
-    emitter
-  });
-  await store.open();
-  let syncEngine = null;
-  let unsubscribeSync = null;
-  if (config.sync) {
-    const transport = new import_sync.WebSocketTransport();
-    const mergeAwareStore = new MergeAwareSyncStore(store, mergeEngine, emitter);
-    const scopeMap = config.sync.scope ? (0, import_core.buildScopeMap)(config.schema, config.sync.scope) : void 0;
-    syncEngine = new import_sync.SyncEngine({
-      transport,
-      store: mergeAwareStore,
-      config: {
-        url: config.sync.url,
-        transport: config.sync.transport,
-        auth: config.sync.auth,
-        batchSize: config.sync.batchSize,
-        schemaVersion: config.sync.schemaVersion ?? config.schema.version,
-        scopeMap
-      },
-      emitter
-    });
-    unsubscribeSync = emitter.on("operation:created", (event) => {
-      if (syncEngine) {
-        syncEngine.pushOperation(event.operation);
-      }
-    });
-  }
-  return { store, syncEngine, unsubscribeSync };
-}
-function createCollectionAccessor(collectionName, getStore) {
-  return {
-    async insert(data) {
-      const currentStore = getStore();
-      if (!currentStore) {
-        throw new Error(`Cannot mutate collection "${collectionName}" before app.ready resolves.`);
-      }
-      return currentStore.collection(collectionName).insert(data);
-    },
-    async findById(id) {
-      const currentStore = getStore();
-      if (!currentStore) return null;
-      return currentStore.collection(collectionName).findById(id);
-    },
-    async update(id, data) {
-      const currentStore = getStore();
-      if (!currentStore) {
-        throw new Error(`Cannot mutate collection "${collectionName}" before app.ready resolves.`);
-      }
-      return currentStore.collection(collectionName).update(id, data);
-    },
-    async delete(id) {
-      const currentStore = getStore();
-      if (!currentStore) {
-        throw new Error(`Cannot mutate collection "${collectionName}" before app.ready resolves.`);
-      }
-      return currentStore.collection(collectionName).delete(id);
-    },
-    where(conditions) {
-      const currentStore = getStore();
-      if (!currentStore) {
-        return createPendingQueryBuilder(conditions);
-      }
-      return currentStore.collection(collectionName).where(conditions);
-    }
-  };
-}
-function createPendingQueryBuilder(initialWhere) {
-  const descriptor = {
-    collection: "__pending__",
-    where: { ...initialWhere },
-    orderBy: [],
-    limit: void 0,
-    offset: void 0
-  };
-  const builder = {
-    where(conditions) {
-      descriptor.where = { ...descriptor.where, ...conditions };
-      return this;
-    },
-    orderBy(field, direction = "asc") {
-      descriptor.orderBy.push({ field, direction });
-      return this;
-    },
-    limit(n) {
-      descriptor.limit = n;
-      return this;
-    },
-    offset(n) {
-      descriptor.offset = n;
-      return this;
-    },
-    async exec() {
-      return [];
-    },
-    async count() {
-      return 0;
-    },
-    subscribe(callback) {
-      void callback([]);
-      return () => {
-      };
-    },
-    getDescriptor() {
-      return { ...descriptor, where: { ...descriptor.where }, orderBy: [...descriptor.orderBy] };
-    }
-  };
-  return builder;
-}
 
 // src/index.ts
-var import_core2 = require("@korajs/core");
-var import_core3 = require("@korajs/core");
-var import_core4 = require("@korajs/core");
-var import_core5 = require("@korajs/core");
+var import_store6 = require("@korajs/store");
 var import_core6 = require("@korajs/core");
 var import_core7 = require("@korajs/core");
-var import_store2 = require("@korajs/store");
-var import_store3 = require("@korajs/store");
-var import_merge2 = require("@korajs/merge");
-var import_sync2 = require("@korajs/sync");
+var import_core8 = require("@korajs/core");
+var import_core9 = require("@korajs/core");
+var import_core10 = require("@korajs/core");
+var import_core11 = require("@korajs/core");
+var import_store7 = require("@korajs/store");
+var import_store8 = require("@korajs/store");
+var import_store9 = require("@korajs/store");
+var import_merge3 = require("@korajs/merge");
+var import_sync7 = require("@korajs/sync");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AppNotReadyError,
   HybridLogicalClock,
   KoraError,
   MergeEngine,
@@ -589,10 +1551,17 @@ var import_sync2 = require("@korajs/sync");
   WebSocketTransport,
   createApp,
   createOperation,
+  decodeAuditExport,
   defineSchema,
+  exportBackup,
   generateUUIDv7,
   migrate,
   op,
-  t
+  readAuditExportManifest,
+  readBackupManifest,
+  restoreBackup,
+  t,
+  verifyAuditExportChecksum,
+  verifyBackupChecksum
 });
 //# sourceMappingURL=index.cjs.map