korajs 0.4.0 → 0.6.0

package/dist/index.js

@@ -1,17 +1,68 @@
+import {
+  ApplyPipeline,
+  MergeAwareSyncStore,
+  StoreQueueStorage,
+  StoreSyncStatePersistence
+} from "./chunk-WALHLVVF.js";
+
 // src/create-app.ts
-import { buildScopeMap } from "@korajs/core";
 import { SimpleEventEmitter } from "@korajs/core/internal";
-import { Instrumenter } from "@korajs/devtools";
 import { MergeEngine } from "@korajs/merge";
+import { QueryStoreCache } from "@korajs/store";
+
+// src/collection-accessor.ts
+import { AppNotReadyError } from "@korajs/core";
+function createCollectionAccessor(collectionName, getStore) {
+  const notReady = (action) => new 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
+import { buildScopeMap } from "@korajs/core";
 import { Store } from "@korajs/store";
-import {
-  ConnectionMonitor,
-  ReconnectionManager,
-  SyncEngine,
-  WebSocketTransport
-} from "@korajs/sync";
+import { SyncEncryptor, SyncEngine } from "@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";
@@ -27,13 +78,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": {
@@ -45,11 +93,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;
@@ -58,219 +106,267 @@ 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;
-  }
-  store;
-  mergeEngine;
-  emitter;
-  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) {
-    if (op2.type !== "update" || !op2.data || !op2.previousData) {
-      return this.store.applyRemoteOperation(op2);
-    }
-    const schema = this.store.getSchema();
-    const collectionDef = schema.collections[op2.collection];
-    if (!collectionDef) {
-      return this.store.applyRemoteOperation(op2);
-    }
-    const accessor = this.store.collection(op2.collection);
-    const currentRecord = await accessor.findById(op2.recordId);
-    if (!currentRecord) {
-      return this.store.applyRemoteOperation(op2);
-    }
-    let hasConflict = false;
-    for (const field of Object.keys(op2.data)) {
-      const expectedBase = op2.previousData[field];
-      const currentLocal = currentRecord[field];
-      if (!deepEqual(expectedBase, currentLocal)) {
-        hasConflict = true;
-        break;
+// src/audit-bridge.ts
+import { persistedAuditTraceFromEvent } from "@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 = persistedAuditTraceFromEvent(event);
+      void store.appendAuditTrace(trace).catch(() => {
+      });
+    })
+  );
+  return () => {
+    for (const unsub of unsubscribers) {
+      unsub();
     }
-    if (!hasConflict) {
-      return this.store.applyRemoteOperation(op2);
-    }
-    this.emitter?.emit({
-      type: "merge:started",
-      operationA: op2,
-      operationB: op2
-    });
-    const baseState = { ...op2.previousData };
-    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)),
-      previousData: op2.previousData,
-      nodeId: this.store.getNodeId()
-    };
-    const input = {
-      local: localOp,
-      remote: op2,
-      baseState,
-      collectionDef
-    };
-    const result = this.mergeEngine.mergeFields(input);
-    for (const trace of result.traces) {
-      this.emitter?.emit({ type: "merge:conflict", trace });
+  };
+}
+
+// src/create-sync-transport.ts
+import { HttpLongPollingTransport, WebSocketTransport } from "@korajs/sync";
+function createSyncTransport(sync) {
+  if (sync.transport === "http") {
+    return new HttpLongPollingTransport();
+  }
+  return new WebSocketTransport();
+}
+
+// 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 firstTrace = result.traces[0];
-    if (firstTrace) {
-      this.emitter?.emit({ type: "merge:completed", trace: firstTrace });
+    if (typeof value !== "object" || Array.isArray(value)) {
+      where[field] = value;
+      continue;
     }
-    const mergedOp = {
-      ...op2,
-      data: result.mergedData
-    };
-    return this.store.applyRemoteOperation(mergedOp);
-  }
-};
-function buildLocalDiff(baseState, currentRecord, fields) {
-  const diff = {};
-  for (const field of fields) {
-    diff[field] = currentRecord[field];
+    skippedFields.push(field);
   }
-  return diff;
-}
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (a === null || b === null) return false;
-  if (a === void 0 || b === void 0) return false;
-  if (typeof a !== typeof b) return false;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    return a.every((val, i) => deepEqual(val, b[i]));
-  }
-  if (typeof a === "object" && typeof b === "object") {
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return false;
-    return keysA.every(
-      (key) => deepEqual(a[key], b[key])
+  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.`
     );
   }
-  return false;
+  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/create-app.ts
-function createApp(config) {
-  const emitter = new SimpleEventEmitter();
-  const mergeEngine = new MergeEngine();
-  let store = null;
+// 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 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;
-  let reconnectionManager = null;
-  let connectionMonitor = null;
-  let instrumenter = null;
-  let intentionalDisconnect = false;
-  let qualityInterval = null;
-  if (config.devtools) {
-    instrumenter = new Instrumenter(emitter, {
-      bridgeEnabled: typeof globalThis !== "undefined" && "window" in globalThis
+  if (config.sync) {
+    const transport = createSyncTransport(config.sync);
+    const mergeAwareStore = new MergeAwareSyncStore(store, mergeEngine, emitter, {
+      onMergeConflict: () => recordConflict?.()
     });
-  }
-  const ready = initializeAsync(config, emitter, mergeEngine).then((result) => {
-    store = result.store;
-    syncEngine = result.syncEngine;
-    unsubscribeSync = result.unsubscribeSync;
-    if (config.sync && syncEngine) {
-      connectionMonitor = new ConnectionMonitor();
-      reconnectionManager = new 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);
-          });
-        });
+    let scopeMap = config.sync.scope ? 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 SyncEncryptor.create(config.sync.encryption) : void 0;
+    syncEngine = new 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
+import { Instrumenter } from "@korajs/devtools";
+function setupDevtools(config, emitter) {
+  if (!config.devtools) {
+    return { instrumenter: null, destroyOverlay: null };
+  }
+  const instrumenter = new Instrumenter(emitter, {
+    bridgeEnabled: typeof globalThis !== "undefined" && "window" in globalThis
   });
-  const syncControl = config.sync ? {
+  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
+import { OFFLINE_SYNC_STATUS } from "@korajs/sync";
+function createSyncControl(options) {
+  const { config, ready, state } = options;
+  if (!config.sync) {
+    return null;
+  }
+  const offlineSyncStatus = () => 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 (syncEngine) {
-        intentionalDisconnect = false;
-        reconnectionManager?.stop();
-        reconnectionManager?.reset();
-        await syncEngine.start();
+      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",
@@ -295,62 +391,344 @@ 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
+import { createSyncStatusController } from "@korajs/sync";
+function createSyncStatusBridge(emitter, getSyncEngine) {
+  const controller = 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
+import {
+  ConnectionMonitor,
+  ReconnectionManager
+} from "@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 ConnectionMonitor();
+  state.reconnectionManager = new 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
+import { KoraError, SchemaValidationError } from "@korajs/core";
+function validateCreateAppConfig(config) {
+  if (!config.schema) {
+    throw new SchemaValidationError("createApp requires a schema.", {
+      fix: "Pass schema: defineSchema({ version: 1, collections: { ... } })"
+    });
+  }
+  if (config.schema.version < 1) {
+    throw new 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 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 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 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 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 SimpleEventEmitter();
+  const mergeEngine = new 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 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.");
@@ -358,45 +736,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
@@ -404,137 +812,33 @@ 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 Store({
-    schema: config.schema,
-    adapter,
-    emitter
-  });
-  await store.open();
-  let syncEngine = null;
-  let unsubscribeSync = null;
-  if (config.sync) {
-    const transport = new WebSocketTransport();
-    const mergeAwareStore = new MergeAwareSyncStore(store, mergeEngine, emitter);
-    const scopeMap = config.sync.scope ? buildScopeMap(config.schema, config.sync.scope) : void 0;
-    syncEngine = new 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
+import {
+  decodeAuditExport,
+  readAuditExportManifest,
+  verifyAuditExportChecksum
+} from "@korajs/store";
 import { defineSchema, migrate, t } from "@korajs/core";
 import { HybridLogicalClock } from "@korajs/core";
 import { generateUUIDv7 } from "@korajs/core";
 import { createOperation } from "@korajs/core";
-import { KoraError } from "@korajs/core";
+import { KoraError as KoraError2, AppNotReadyError as AppNotReadyError2 } from "@korajs/core";
 import { op } from "@korajs/core";
 import { SequenceManager, Store as Store2 } from "@korajs/store";
 import { TransactionContext } from "@korajs/store";
+import {
+  exportBackup,
+  readBackupManifest,
+  restoreBackup,
+  verifyBackupChecksum
+} from "@korajs/store";
 import { MergeEngine as MergeEngine2 } from "@korajs/merge";
 import { SyncEngine as SyncEngine2, WebSocketTransport as WebSocketTransport2 } from "@korajs/sync";
 export {
+  AppNotReadyError2 as AppNotReadyError,
   HybridLogicalClock,
-  KoraError,
+  KoraError2 as KoraError,
   MergeEngine2 as MergeEngine,
   SequenceManager,
   Store2 as Store,
@@ -543,10 +847,17 @@ export {
   WebSocketTransport2 as WebSocketTransport,
   createApp,
   createOperation,
+  decodeAuditExport,
   defineSchema,
+  exportBackup,
   generateUUIDv7,
   migrate,
   op,
-  t
+  readAuditExportManifest,
+  readBackupManifest,
+  restoreBackup,
+  t,
+  verifyAuditExportChecksum,
+  verifyBackupChecksum
 };
 //# sourceMappingURL=index.js.map