korajs 0.3.5 → 0.5.0

package/dist/index.js

@@ -1,11 +1,30 @@
+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 { Store } from "@korajs/store";
-import { ConnectionMonitor, ReconnectionManager, SyncEngine, WebSocketTransport } from "@korajs/sync";
+import {
+  ConnectionMonitor,
+  HttpLongPollingTransport,
+  ReconnectionManager,
+  SyncEncryptor,
+  SyncEngine,
+  WebSocketTransport
+} 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";
@@ -21,13 +40,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": {
@@ -39,11 +55,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;
@@ -52,133 +68,289 @@ 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();
+// src/app-not-ready-error.ts
+import { KoraError } from "@korajs/core";
+var AppNotReadyError = class extends 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";
   }
-  getNodeId() {
-    return this.store.getNodeId();
+};
+
+// 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();
+    }
+  };
+}
+
+// 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;
+    }
   }
-  async getOperationRange(nodeId, fromSeq, toSeq) {
-    return this.store.getOperationRange(nodeId, fromSeq, toSeq);
+  if (Object.keys(where).length === 0) {
+    return null;
   }
-  async applyRemoteOperation(op) {
-    if (op.type !== "update" || !op.data || !op.previousData) {
-      return this.store.applyRemoteOperation(op);
+  return {
+    collection: descriptor.collection,
+    where
+  };
+}
+function createSyncQuerySubscriptionHook(getSyncEngine) {
+  return (descriptor) => {
+    const subset = queryDescriptorToSyncSubset(descriptor);
+    if (!subset) {
+      return () => {
+      };
     }
-    const schema = this.store.getSchema();
-    const collectionDef = schema.collections[op.collection];
-    if (!collectionDef) {
-      return this.store.applyRemoteOperation(op);
+    const engine = getSyncEngine();
+    if (!engine) {
+      return () => {
+      };
     }
-    const accessor = this.store.collection(op.collection);
-    const currentRecord = await accessor.findById(op.recordId);
-    if (!currentRecord) {
-      return this.store.applyRemoteOperation(op);
+    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;
     }
-    let hasConflict = false;
-    for (const field of Object.keys(op.data)) {
-      const expectedBase = op.previousData[field];
-      const currentLocal = currentRecord[field];
-      if (!deepEqual(expectedBase, currentLocal)) {
-        hasConflict = true;
-        break;
-      }
+    currentStatus = next;
+    for (const listener of listeners) {
+      listener(currentStatus);
     }
-    if (!hasConflict) {
-      return this.store.applyRemoteOperation(op);
+  };
+  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();
     }
-    this.emitter?.emit({
-      type: "merge:started",
-      operationA: op,
-      operationB: op
+  };
+  refresh();
+  return bridge;
+}
+
+// src/validate-config.ts
+import { KoraError as KoraError2, SchemaValidationError } from "@korajs/core";
+function validateCreateAppConfig(config) {
+  if (!config.schema) {
+    throw new SchemaValidationError("createApp requires a schema.", {
+      fix: "Pass schema: defineSchema({ version: 1, collections: { ... } })"
     });
-    const baseState = { ...op.previousData };
-    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()
-    };
-    const input = {
-      local: localOp,
-      remote: op,
-      baseState,
-      collectionDef
-    };
-    const result = this.mergeEngine.mergeFields(input);
-    for (const trace of result.traces) {
-      this.emitter?.emit({ type: "merge:conflict", trace });
-    }
-    const firstTrace = result.traces[0];
-    if (firstTrace) {
-      this.emitter?.emit({ type: "merge:completed", trace: firstTrace });
-    }
-    const mergedOp = {
-      ...op,
-      data: result.mergedData
-    };
-    return this.store.applyRemoteOperation(mergedOp);
   }
-};
-function buildLocalDiff(baseState, currentRecord, fields) {
-  const diff = {};
-  for (const field of fields) {
-    diff[field] = currentRecord[field];
+  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 KoraError2(
+      "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 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]));
+function validateSyncUrl(url, transport) {
+  if (!url || url.trim().length === 0) {
+    throw new KoraError2("sync.url is required when sync is configured.", "INVALID_SYNC_URL", {
+      fix: 'Pass sync: { url: "wss://your-server/kora" }.'
+    });
   }
-  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])
+  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 KoraError2(
+      `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."
+      }
     );
   }
-  return false;
 }
 
 // src/create-app.ts
 function createApp(config) {
+  validateCreateAppConfig(config);
   const emitter = new SimpleEventEmitter();
   const mergeEngine = new 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 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 ConnectionMonitor();
       reconnectionManager = new ReconnectionManager({
@@ -203,10 +375,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();
@@ -223,9 +409,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) {
@@ -233,6 +442,7 @@ function createApp(config) {
         reconnectionManager?.stop();
         reconnectionManager?.reset();
         await syncEngine.start();
+        syncStatusBridge?.refresh();
       }
     },
     async disconnect() {
@@ -241,19 +451,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.");
@@ -263,6 +551,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;
@@ -271,6 +565,10 @@ function createApp(config) {
         qualityInterval = null;
       }
       reconnectionManager?.stop();
+      if (destroyDevtoolsOverlay) {
+        destroyDevtoolsOverlay();
+        destroyDevtoolsOverlay = null;
+      }
       if (instrumenter) {
         instrumenter.destroy();
         instrumenter = null;
@@ -279,15 +577,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)) {
@@ -304,37 +638,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 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 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 WebSocketTransport();
-    const mergeAwareStore = new MergeAwareSyncStore(store, mergeEngine, emitter);
+    const transport = createSyncTransport(config.sync);
+    const mergeAwareStore = new MergeAwareSyncStore(store, mergeEngine, emitter, {
+      onMergeConflict: () => recordConflict?.()
+    });
+    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: 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 HttpLongPollingTransport();
+  }
+  return new WebSocketTransport();
 }
 function createCollectionAccessor(collectionName, getStore) {
   return {
@@ -399,15 +783,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] };
@@ -417,25 +805,49 @@ function createPendingQueryBuilder(initialWhere) {
 }
 
 // src/index.ts
-import { defineSchema, t } from "@korajs/core";
+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 { Store as Store2 } from "@korajs/store";
+import { KoraError as KoraError3 } 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 {
   HybridLogicalClock,
-  KoraError,
+  KoraError3 as KoraError,
   MergeEngine2 as MergeEngine,
+  SequenceManager,
   Store2 as Store,
   SyncEngine2 as SyncEngine,
+  TransactionContext,
   WebSocketTransport2 as WebSocketTransport,
   createApp,
   createOperation,
+  decodeAuditExport,
   defineSchema,
+  exportBackup,
   generateUUIDv7,
-  t
+  migrate,
+  op,
+  readAuditExportManifest,
+  readBackupManifest,
+  restoreBackup,
+  t,
+  verifyAuditExportChecksum,
+  verifyBackupChecksum
 };
 //# sourceMappingURL=index.js.map