korajs 0.3.5 → 0.5.0

package/dist/index.cjs

@@ -30,28 +30,44 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  HybridLogicalClock: () => import_core2.HybridLogicalClock,
-  KoraError: () => import_core5.KoraError,
-  MergeEngine: () => import_merge2.MergeEngine,
-  Store: () => import_store2.Store,
-  SyncEngine: () => import_sync2.SyncEngine,
-  WebSocketTransport: () => import_sync2.WebSocketTransport,
+  HybridLogicalClock: () => import_core7.HybridLogicalClock,
+  KoraError: () => import_core10.KoraError,
+  MergeEngine: () => import_merge3.MergeEngine,
+  SequenceManager: () => import_store6.SequenceManager,
+  Store: () => import_store6.Store,
+  SyncEngine: () => import_sync3.SyncEngine,
+  TransactionContext: () => import_store7.TransactionContext,
+  WebSocketTransport: () => import_sync3.WebSocketTransport,
   createApp: () => createApp,
-  createOperation: () => import_core4.createOperation,
-  defineSchema: () => import_core.defineSchema,
-  generateUUIDv7: () => import_core3.generateUUIDv7,
-  t: () => import_core.t
+  createOperation: () => import_core9.createOperation,
+  decodeAuditExport: () => import_store5.decodeAuditExport,
+  defineSchema: () => import_core6.defineSchema,
+  exportBackup: () => import_store8.exportBackup,
+  generateUUIDv7: () => import_core8.generateUUIDv7,
+  migrate: () => import_core6.migrate,
+  op: () => import_core11.op,
+  readAuditExportManifest: () => import_store5.readAuditExportManifest,
+  readBackupManifest: () => import_store8.readBackupManifest,
+  restoreBackup: () => import_store8.restoreBackup,
+  t: () => import_core6.t,
+  verifyAuditExportChecksum: () => import_store5.verifyAuditExportChecksum,
+  verifyBackupChecksum: () => import_store8.verifyBackupChecksum
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/create-app.ts
-var import_internal = require("@korajs/core/internal");
+var import_core5 = require("@korajs/core");
+var import_internal5 = 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");
+var import_merge2 = require("@korajs/merge");
+var import_store4 = require("@korajs/store");
+var import_sync2 = 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";
@@ -67,13 +83,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": {
@@ -85,11 +98,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;
@@ -98,85 +111,536 @@ 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/app-not-ready-error.ts
+var import_core = require("@korajs/core");
+var AppNotReadyError = class extends import_core.KoraError {
+  constructor(detail) {
+    super(detail, "APP_NOT_READY", {
+      fix: "Await app.ready, or wrap your UI in <KoraProvider app={app}> before calling useQuery()."
+    });
+    this.name = "AppNotReadyError";
   }
-  store;
-  mergeEngine;
-  emitter;
-  getVersionVector() {
-    return this.store.getVersionVector();
+};
+
+// 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]
+        }
+      ]
+    };
   }
-  getNodeId() {
-    return this.store.getNodeId();
+  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());
   }
-  async getOperationRange(nodeId, fromSeq, toSeq) {
-    return this.store.getOperationRange(nodeId, fromSeq, toSeq);
+  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);
+  }
+  /** Local update. */
+  async update(collection, id, data) {
+    return (0, import_internal3.executeUpdate)(this.deps.store.createMutationContext(collection), id, data);
   }
-  async applyRemoteOperation(op) {
-    if (op.type !== "update" || !op.data || !op.previousData) {
-      return this.store.applyRemoteOperation(op);
+  /**
+   * 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 schema = this.store.getSchema();
-    const collectionDef = schema.collections[op.collection];
+    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 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(op);
+      return this.deps.store.applyRemoteOperation(op2);
     }
-    const accessor = this.store.collection(op.collection);
-    const currentRecord = await accessor.findById(op.recordId);
+    const accessor = this.deps.store.collection(op2.collection);
+    const currentRecord = await accessor.findById(op2.recordId);
     if (!currentRecord) {
-      return this.store.applyRemoteOperation(op);
+      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(op.data)) {
-      const expectedBase = op.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(op);
+      return this.deps.store.applyRemoteOperation(op2);
     }
-    this.emitter?.emit({
-      type: "merge:started",
-      operationA: op,
-      operationB: op
+    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 = { ...op.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 = {
-      ...op,
-      // The "local" operation's data is the diff between base and current local state
-      data: buildLocalDiff(op.previousData, currentRecord, Object.keys(op.data)),
-      previousData: op.previousData,
-      nodeId: this.store.getNodeId()
+      ...op2,
+      data: buildLocalDiff(baseState, currentRecord, Object.keys(op2.data ?? {})),
+      previousData: op2.previousData,
+      nodeId: this.deps.store.getNodeId(),
+      timestamp: localTimestamp
     };
-    const input = {
+    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 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: op,
-      baseState,
+      remote: op2,
+      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?.();
     }
-    const firstTrace = result.traces[0];
+    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 = mergeResult.traces[0];
     if (firstTrace) {
-      this.emitter?.emit({ type: "merge:completed", trace: firstTrace });
+      this.deps.emitter?.emit({ type: "merge:completed", trace: firstTrace });
     }
-    const mergedOp = {
-      ...op,
-      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) {
@@ -184,6 +648,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;
@@ -204,30 +682,385 @@ function deepEqual(a, b) {
   return false;
 }
 
+// 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/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
+    });
+  }
+  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_sync = 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_sync.operationMatchesScope)(op2, this.scope));
+  }
+  loadDeltaCursor() {
+    return this.store.loadDeltaCursor().then((encoded) => (0, import_sync.decodeDeltaCursor)(encoded));
+  }
+  async saveDeltaCursor(cursor) {
+    await this.store.saveDeltaCursor(cursor ? (0, import_sync.encodeDeltaCursor)(cursor) : null);
+  }
+};
+
+// src/sync-query-bridge.ts
+function queryDescriptorToSyncSubset(descriptor) {
+  const where = {};
+  for (const [field, value] of Object.entries(descriptor.where)) {
+    if (value === null || value === void 0) {
+      where[field] = value;
+      continue;
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+      where[field] = value;
+    }
+  }
+  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/sync-status-bridge.ts
+var OFFLINE_STATUS = Object.freeze({
+  status: "offline",
+  pendingOperations: 0,
+  lastSyncedAt: null,
+  lastSuccessfulPush: null,
+  lastSuccessfulPull: null,
+  conflicts: 0
+});
+var SYNC_STATUS_EVENT_TYPES = [
+  "sync:connected",
+  "sync:disconnected",
+  "sync:schema-mismatch",
+  "sync:auth-failed",
+  "sync:sent",
+  "sync:received",
+  "sync:acknowledged",
+  "sync:apply-failed",
+  "sync:diagnostics",
+  "sync:initial-sync-progress"
+];
+function createSyncStatusBridge(emitter, getSyncEngine) {
+  let currentStatus = OFFLINE_STATUS;
+  const listeners = /* @__PURE__ */ new Set();
+  const refresh = () => {
+    const engine = getSyncEngine();
+    const next = engine ? engine.getStatus() : OFFLINE_STATUS;
+    const prevSerialized = JSON.stringify(currentStatus);
+    const nextSerialized = JSON.stringify(next);
+    if (prevSerialized === nextSerialized) {
+      return;
+    }
+    currentStatus = next;
+    for (const listener of listeners) {
+      listener(currentStatus);
+    }
+  };
+  const unsubs = [];
+  for (const type of SYNC_STATUS_EVENT_TYPES) {
+    unsubs.push(emitter.on(type, refresh));
+  }
+  const bridge = {
+    get status() {
+      return currentStatus;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(currentStatus);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    refresh,
+    destroy() {
+      for (const unsub of unsubs) {
+        unsub();
+      }
+      unsubs.length = 0;
+      listeners.clear();
+    }
+  };
+  refresh();
+  return bridge;
+}
+
+// src/validate-config.ts
+var import_core4 = require("@korajs/core");
+function validateCreateAppConfig(config) {
+  if (!config.schema) {
+    throw new import_core4.SchemaValidationError("createApp requires a schema.", {
+      fix: "Pass schema: defineSchema({ version: 1, collections: { ... } })"
+    });
+  }
+  if (config.schema.version < 1) {
+    throw new import_core4.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_core4.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_core4.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).'
+      }
+    );
+  }
+}
+function validateSyncUrl(url, transport) {
+  if (!url || url.trim().length === 0) {
+    throw new import_core4.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_core4.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/create-app.ts
 function createApp(config) {
-  const emitter = new import_internal.SimpleEventEmitter();
-  const mergeEngine = new import_merge.MergeEngine();
+  validateCreateAppConfig(config);
+  const emitter = new import_internal5.SimpleEventEmitter();
+  const mergeEngine = new import_merge2.MergeEngine();
+  if (config.onSyncEvent) {
+    const handler = config.onSyncEvent;
+    const syncTypes = [
+      "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"
+    ];
+    for (const type of syncTypes) {
+      emitter.on(type, (event) => {
+        handler(event);
+      });
+    }
+  }
   let store = null;
   let syncEngine = null;
   let unsubscribeSync = null;
+  let unsubscribeAudit = null;
   let reconnectionManager = null;
   let connectionMonitor = null;
   let instrumenter = null;
   let intentionalDisconnect = false;
   let qualityInterval = null;
+  let syncStatusBridge = null;
+  let destroyDevtoolsOverlay = null;
   if (config.devtools) {
     instrumenter = new import_devtools.Instrumenter(emitter, {
       bridgeEnabled: typeof globalThis !== "undefined" && "window" in globalThis
     });
+    if (typeof globalThis !== "undefined" && "window" in globalThis) {
+      void import("@korajs/devtools/overlay").then(({ mountKoraDevtoolsOverlay }) => {
+        if (instrumenter) {
+          destroyDevtoolsOverlay = mountKoraDevtoolsOverlay(instrumenter);
+        }
+      }).catch(() => {
+      });
+    }
   }
   const ready = initializeAsync(config, emitter, mergeEngine).then((result) => {
     store = result.store;
     syncEngine = result.syncEngine;
     unsubscribeSync = result.unsubscribeSync;
+    unsubscribeAudit = result.unsubscribeAudit;
+    const authBinding = result.authBinding;
+    if (config.sync) {
+      syncStatusBridge = createSyncStatusBridge(emitter, () => syncEngine);
+      syncStatusBridge.refresh();
+    }
+    if (config.sync && syncEngine && authBinding?.subscribe) {
+      authBinding.subscribe(() => {
+        const engine = syncEngine;
+        if (!engine) {
+          return;
+        }
+        void (async () => {
+          const headers = await authBinding.auth();
+          if (!headers.token) {
+            await engine.stop();
+            return;
+          }
+          if (authBinding.resolveScopeMap) {
+            const nextScope = await authBinding.resolveScopeMap();
+            engine.updateScope(nextScope);
+          }
+          const status = engine.getStatus().status;
+          if (status !== "offline") {
+            await engine.stop();
+          }
+          await engine.start();
+        })();
+      });
+    }
     if (config.sync && syncEngine) {
-      connectionMonitor = new import_sync.ConnectionMonitor();
-      reconnectionManager = new import_sync.ReconnectionManager({
+      connectionMonitor = new import_sync2.ConnectionMonitor();
+      reconnectionManager = new import_sync2.ReconnectionManager({
         initialDelay: config.sync.reconnectInterval,
         maxDelay: config.sync.maxReconnectInterval
       });
@@ -249,10 +1082,24 @@ function createApp(config) {
           qualityInterval = null;
         }
       });
+      const browserGlobal = globalThis;
+      if (typeof browserGlobal.addEventListener === "function") {
+        const engine = syncEngine;
+        browserGlobal.addEventListener("online", () => {
+          if (intentionalDisconnect || config.sync?.autoReconnect === false) return;
+          reconnectionManager?.wake();
+          reconnectionManager?.reset();
+          void engine.retryNow();
+        });
+      }
+      emitter.on("sync:schema-mismatch", () => {
+        reconnectionManager?.stop();
+        intentionalDisconnect = true;
+      });
       if (config.sync.autoReconnect !== false) {
         const engine = syncEngine;
         emitter.on("sync:disconnected", () => {
-          if (intentionalDisconnect) return;
+          if (intentionalDisconnect || engine.isSchemaBlocked()) return;
           if (reconnectionManager?.isRunning()) return;
           engine.setReconnecting(true);
           reconnectionManager?.stop();
@@ -269,9 +1116,32 @@ function createApp(config) {
           });
         });
       }
+      if (config.sync.autoConnect === true && syncEngine) {
+        void syncEngine.start().catch(() => {
+        });
+      }
     }
   });
+  const offlineSyncStatus = () => ({
+    status: "offline",
+    pendingOperations: 0,
+    lastSyncedAt: null,
+    lastSuccessfulPush: null,
+    lastSuccessfulPull: null,
+    conflicts: 0
+  });
   const syncControl = config.sync ? {
+    get status() {
+      return syncStatusBridge?.status ?? offlineSyncStatus();
+    },
+    subscribeStatus(listener) {
+      if (syncStatusBridge) {
+        return syncStatusBridge.subscribe(listener);
+      }
+      listener(offlineSyncStatus());
+      return () => {
+      };
+    },
     async connect() {
       await ready;
       if (syncEngine) {
@@ -279,6 +1149,7 @@ function createApp(config) {
         reconnectionManager?.stop();
         reconnectionManager?.reset();
         await syncEngine.start();
+        syncStatusBridge?.refresh();
       }
     },
     async disconnect() {
@@ -287,19 +1158,97 @@ function createApp(config) {
         intentionalDisconnect = true;
         reconnectionManager?.stop();
         await syncEngine.stop();
+        syncStatusBridge?.refresh();
       }
     },
     getStatus() {
       if (syncEngine) {
         return syncEngine.getStatus();
       }
-      return { status: "offline", pendingOperations: 0, lastSyncedAt: null };
+      return offlineSyncStatus();
+    },
+    async retryNow() {
+      await ready;
+      if (syncEngine) {
+        await syncEngine.retryNow();
+      }
+    },
+    clearSchemaBlock() {
+      syncEngine?.clearSchemaBlock();
+    },
+    exportDiagnostics() {
+      if (syncEngine) {
+        return syncEngine.exportDiagnostics();
+      }
+      return {
+        state: "disconnected",
+        status: {
+          status: "offline",
+          pendingOperations: 0,
+          lastSyncedAt: null,
+          lastSuccessfulPush: null,
+          lastSuccessfulPull: null,
+          conflicts: 0
+        },
+        nodeId: "",
+        url: config.sync?.url ?? "",
+        schemaVersion: config.schema.version,
+        lastSyncedAt: null,
+        lastSuccessfulPush: null,
+        lastSuccessfulPull: null,
+        conflicts: 0,
+        pendingOperations: 0,
+        hasInFlightBatch: false,
+        reconnecting: false,
+        timestamp: Date.now()
+      };
     }
   } : null;
+  async function executeTransaction(fn, mutationName) {
+    await ready;
+    if (!store) {
+      throw new Error("Store not initialized. Await app.ready before using transactions.");
+    }
+    const collectionNames = Object.keys(config.schema.collections);
+    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 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);
+    }
+  };
   const app = {
     ready,
     events: emitter,
     sync: syncControl,
+    sequences,
     getStore() {
       if (!store) {
         throw new Error("Store not initialized. Await app.ready before accessing the store.");
@@ -309,6 +1258,12 @@ function createApp(config) {
     getSyncEngine() {
       return syncEngine;
     },
+    async transaction(fn) {
+      return executeTransaction(fn);
+    },
+    async mutation(name, fn) {
+      return executeTransaction(fn, name);
+    },
     async close() {
       await ready;
       intentionalDisconnect = true;
@@ -317,6 +1272,10 @@ function createApp(config) {
         qualityInterval = null;
       }
       reconnectionManager?.stop();
+      if (destroyDevtoolsOverlay) {
+        destroyDevtoolsOverlay();
+        destroyDevtoolsOverlay = null;
+      }
       if (instrumenter) {
         instrumenter.destroy();
         instrumenter = null;
@@ -325,15 +1284,51 @@ function createApp(config) {
         unsubscribeSync();
         unsubscribeSync = null;
       }
+      if (unsubscribeAudit) {
+        unsubscribeAudit();
+        unsubscribeAudit = null;
+      }
       if (syncEngine) {
         await syncEngine.stop();
         syncEngine = null;
       }
+      if (syncStatusBridge) {
+        syncStatusBridge.destroy();
+        syncStatusBridge = null;
+      }
       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)) {
@@ -350,37 +1345,87 @@ function createApp(config) {
 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({
+  const adapter = await createAdapter(
+    adapterType,
+    dbName,
+    config.store?.workerUrl,
+    emitter,
+    config.store?.workerResponseTimeoutMs,
+    config.store?.sharedWorkerUrl
+  );
+  const authBinding = config.sync?.authClient;
+  const authNodeId = authBinding?.resolveNodeId ? await authBinding.resolveNodeId() : void 0;
+  let syncEngine = null;
+  const store = new import_store4.Store({
     schema: config.schema,
     adapter,
-    emitter
+    emitter,
+    dbName,
+    nodeId: authNodeId,
+    isolation: authNodeId ? "shared" : config.store?.isolation,
+    ...config.sync ? { onQuerySubscribed: createSyncQuerySubscriptionHook(() => syncEngine) } : {}
   });
   await store.open();
-  let syncEngine = null;
+  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 = new import_sync.WebSocketTransport();
-    const mergeAwareStore = new MergeAwareSyncStore(store, mergeEngine, emitter);
-    syncEngine = new import_sync.SyncEngine({
+    const transport = createSyncTransport(config.sync);
+    const mergeAwareStore = new MergeAwareSyncStore(store, mergeEngine, emitter, {
+      onMergeConflict: () => recordConflict?.()
+    });
+    let scopeMap = config.sync.scope ? (0, import_core5.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_sync2.SyncEncryptor.create(config.sync.encryption) : void 0;
+    syncEngine = new import_sync2.SyncEngine({
       transport,
       store: mergeAwareStore,
       config: {
         url: config.sync.url,
         transport: config.sync.transport,
-        auth: config.sync.auth,
+        auth: syncAuth,
         batchSize: config.sync.batchSize,
-        schemaVersion: config.sync.schemaVersion ?? config.schema.version
+        schemaVersion: config.sync.schemaVersion ?? config.schema.version,
+        scopeMap,
+        encryption: config.sync.encryption,
+        strictHandshake: config.sync.strictHandshake,
+        operationTransforms: config.sync.operationTransforms
       },
-      emitter
+      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 };
+  return {
+    store,
+    syncEngine,
+    unsubscribeSync,
+    unsubscribeAudit,
+    authBinding: config.sync?.authClient ?? null
+  };
+}
+function createSyncTransport(sync) {
+  if (sync.transport === "http") {
+    return new import_sync2.HttpLongPollingTransport();
+  }
+  return new import_sync2.WebSocketTransport();
 }
 function createCollectionAccessor(collectionName, getStore) {
   return {
@@ -445,15 +1490,19 @@ function createPendingQueryBuilder(initialWhere) {
       return this;
     },
     async exec() {
-      return [];
+      throw new AppNotReadyError(
+        "Cannot execute a query before app.ready. Await app.ready or use <KoraProvider app={app}>."
+      );
     },
     async count() {
-      return 0;
+      throw new AppNotReadyError(
+        "Cannot count query results before app.ready. Await app.ready or use <KoraProvider app={app}>."
+      );
     },
-    subscribe(callback) {
-      void callback([]);
-      return () => {
-      };
+    subscribe(_callback) {
+      throw new AppNotReadyError(
+        "Cannot subscribe to a query before app.ready. Await app.ready or use <KoraProvider app={app}>."
+      );
     },
     getDescriptor() {
       return { ...descriptor, where: { ...descriptor.where }, orderBy: [...descriptor.orderBy] };
@@ -463,26 +1512,41 @@ function createPendingQueryBuilder(initialWhere) {
 }
 
 // src/index.ts
-var import_core = require("@korajs/core");
-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_store2 = require("@korajs/store");
-var import_merge2 = require("@korajs/merge");
-var import_sync2 = require("@korajs/sync");
+var import_store5 = require("@korajs/store");
+var import_core6 = require("@korajs/core");
+var import_core7 = require("@korajs/core");
+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_store6 = require("@korajs/store");
+var import_store7 = require("@korajs/store");
+var import_store8 = require("@korajs/store");
+var import_merge3 = require("@korajs/merge");
+var import_sync3 = require("@korajs/sync");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HybridLogicalClock,
   KoraError,
   MergeEngine,
+  SequenceManager,
   Store,
   SyncEngine,
+  TransactionContext,
   WebSocketTransport,
   createApp,
   createOperation,
+  decodeAuditExport,
   defineSchema,
+  exportBackup,
   generateUUIDv7,
-  t
+  migrate,
+  op,
+  readAuditExportManifest,
+  readBackupManifest,
+  restoreBackup,
+  t,
+  verifyAuditExportChecksum,
+  verifyBackupChecksum
 });
 //# sourceMappingURL=index.cjs.map