korajs 0.5.0 → 0.6.1

package/dist/index.cjs

@@ -30,38 +30,84 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AppNotReadyError: () => import_core10.AppNotReadyError,
   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,
+  SequenceManager: () => import_store7.SequenceManager,
+  Store: () => import_store7.Store,
+  SyncEngine: () => import_sync7.SyncEngine,
+  TransactionContext: () => import_store8.TransactionContext,
+  WebSocketTransport: () => import_sync7.WebSocketTransport,
   createApp: () => createApp,
   createOperation: () => import_core9.createOperation,
-  decodeAuditExport: () => import_store5.decodeAuditExport,
+  decodeAuditExport: () => import_store6.decodeAuditExport,
   defineSchema: () => import_core6.defineSchema,
-  exportBackup: () => import_store8.exportBackup,
+  exportBackup: () => import_store9.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,
+  readAuditExportManifest: () => import_store6.readAuditExportManifest,
+  readBackupManifest: () => import_store9.readBackupManifest,
+  restoreBackup: () => import_store9.restoreBackup,
   t: () => import_core6.t,
-  verifyAuditExportChecksum: () => import_store5.verifyAuditExportChecksum,
-  verifyBackupChecksum: () => import_store8.verifyBackupChecksum
+  verifyAuditExportChecksum: () => import_store6.verifyAuditExportChecksum,
+  verifyBackupChecksum: () => import_store9.verifyBackupChecksum
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/create-app.ts
-var import_core5 = require("@korajs/core");
 var import_internal5 = require("@korajs/core/internal");
-var import_devtools = require("@korajs/devtools");
 var import_merge2 = require("@korajs/merge");
+var import_store5 = require("@korajs/store");
+
+// src/collection-accessor.ts
+var import_core = require("@korajs/core");
+function createCollectionAccessor(collectionName, getStore) {
+  const notReady = (action) => new import_core.AppNotReadyError(
+    `Cannot ${action} on collection "${collectionName}" before app.ready. Await app.ready or use <KoraProvider app={app}>.`
+  );
+  return {
+    async insert(data) {
+      const currentStore = getStore();
+      if (!currentStore) {
+        throw notReady("insert into");
+      }
+      return currentStore.collection(collectionName).insert(data);
+    },
+    async findById(id) {
+      const currentStore = getStore();
+      if (!currentStore) return null;
+      return currentStore.collection(collectionName).findById(id);
+    },
+    async update(id, data) {
+      const currentStore = getStore();
+      if (!currentStore) {
+        throw notReady("update");
+      }
+      return currentStore.collection(collectionName).update(id, data);
+    },
+    async delete(id) {
+      const currentStore = getStore();
+      if (!currentStore) {
+        throw notReady("delete from");
+      }
+      return currentStore.collection(collectionName).delete(id);
+    },
+    where(conditions) {
+      const currentStore = getStore();
+      if (!currentStore) {
+        throw notReady("query");
+      }
+      return currentStore.collection(collectionName).where(conditions);
+    }
+  };
+}
+
+// src/initialize-app.ts
+var import_core4 = require("@korajs/core");
 var import_store4 = require("@korajs/store");
-var import_sync2 = require("@korajs/sync");
+var import_sync3 = require("@korajs/sync");
 
 // src/adapter-resolver.ts
 function importOptionalPeer(specifier) {
@@ -111,17 +157,6 @@ async function createAdapter(type, dbName, workerUrl, emitter, workerResponseTim
   }
 }
 
-// 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";
-  }
-};
-
 // src/apply-pipeline.ts
 var import_core3 = require("@korajs/core");
 var import_internal2 = require("@korajs/core/internal");
@@ -706,6 +741,15 @@ function wireAuditPersistence(store, emitter) {
   };
 }
 
+// src/create-sync-transport.ts
+var import_sync = require("@korajs/sync");
+function createSyncTransport(sync) {
+  if (sync.transport === "http") {
+    return new import_sync.HttpLongPollingTransport();
+  }
+  return new import_sync.WebSocketTransport();
+}
+
 // src/merge-aware-sync-store.ts
 var MergeAwareSyncStore = class {
   constructor(store, mergeEngine, emitter, options) {
@@ -777,7 +821,7 @@ function operationFromQueuePayload(payload) {
 
 // src/store-sync-state.ts
 var import_store3 = require("@korajs/store");
-var import_sync = require("@korajs/sync");
+var import_sync2 = require("@korajs/sync");
 var StoreSyncStatePersistence = class {
   constructor(store, scope) {
     this.store = store;
@@ -800,19 +844,20 @@ var StoreSyncStatePersistence = class {
   }
   async getUnsyncedOperations(serverVector) {
     const ops = await this.store.getUnsyncedOperations(serverVector);
-    return ops.filter((op2) => (0, import_sync.operationMatchesScope)(op2, this.scope));
+    return ops.filter((op2) => (0, import_sync2.operationMatchesScope)(op2, this.scope));
   }
   loadDeltaCursor() {
-    return this.store.loadDeltaCursor().then((encoded) => (0, import_sync.decodeDeltaCursor)(encoded));
+    return this.store.loadDeltaCursor().then((encoded) => (0, import_sync2.decodeDeltaCursor)(encoded));
   }
   async saveDeltaCursor(cursor) {
-    await this.store.saveDeltaCursor(cursor ? (0, import_sync.encodeDeltaCursor)(cursor) : null);
+    await this.store.saveDeltaCursor(cursor ? (0, import_sync2.encodeDeltaCursor)(cursor) : null);
   }
 };
 
 // src/sync-query-bridge.ts
 function queryDescriptorToSyncSubset(descriptor) {
   const where = {};
+  const skippedFields = [];
   for (const [field, value] of Object.entries(descriptor.where)) {
     if (value === null || value === void 0) {
       where[field] = value;
@@ -820,7 +865,14 @@ function queryDescriptorToSyncSubset(descriptor) {
     }
     if (typeof value !== "object" || Array.isArray(value)) {
       where[field] = value;
+      continue;
     }
+    skippedFields.push(field);
+  }
+  if (skippedFields.length > 0 && typeof console !== "undefined") {
+    console.warn(
+      `[Kora] Sync query subset omitted non-equality filters on ${descriptor.collection}: ${skippedFields.join(", ")}. Only plain equality WHERE clauses are registered for incremental sync.`
+    );
   }
   if (Object.keys(where).length === 0) {
     return null;
@@ -846,297 +898,148 @@ function createSyncQuerySubscriptionHook(getSyncEngine) {
   };
 }
 
-// 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;
+// src/initialize-app.ts
+async function initializeApp(config, emitter, mergeEngine) {
+  const adapterType = config.store?.adapter ?? detectAdapterType();
+  const dbName = config.store?.name ?? "kora-db";
+  const adapter = await createAdapter(
+    adapterType,
+    dbName,
+    config.store?.workerUrl,
+    emitter,
+    config.store?.workerResponseTimeoutMs,
+    config.store?.sharedWorkerUrl
+  );
+  const authBinding = config.sync?.authClient ?? null;
+  const authNodeId = authBinding?.resolveNodeId ? await authBinding.resolveNodeId() : void 0;
+  let syncEngine = null;
+  const store = new import_store4.Store({
+    schema: config.schema,
+    adapter,
+    emitter,
+    dbName,
+    nodeId: authNodeId,
+    isolation: authNodeId ? "shared" : config.store?.isolation,
+    ...config.sync ? { onQuerySubscribed: createSyncQuerySubscriptionHook(() => syncEngine) } : {}
+  });
+  await store.open();
+  let recordConflict;
+  const applyPipeline = new ApplyPipeline({
+    store,
+    mergeEngine,
+    emitter,
+    onMergeConflict: () => recordConflict?.()
+  });
+  store.setLocalMutationHandler(applyPipeline);
+  const unsubscribeAudit = wireAuditPersistence(store, emitter);
+  let unsubscribeSync = null;
+  if (config.sync) {
+    const transport = createSyncTransport(config.sync);
+    const mergeAwareStore = new MergeAwareSyncStore(store, mergeEngine, emitter, {
+      onMergeConflict: () => recordConflict?.()
+    });
+    let scopeMap = config.sync.scope ? (0, import_core4.buildScopeMap)(config.schema, config.sync.scope) : void 0;
+    if (authBinding?.resolveScopeMap) {
+      scopeMap = await authBinding.resolveScopeMap() ?? scopeMap;
     }
-    currentStatus = next;
-    for (const listener of listeners) {
-      listener(currentStatus);
+    const syncAuth = authBinding?.auth ?? config.sync.auth;
+    const encryptor = config.sync.encryption?.enabled === true ? await import_sync3.SyncEncryptor.create(config.sync.encryption) : void 0;
+    syncEngine = new import_sync3.SyncEngine({
+      transport,
+      store: mergeAwareStore,
+      config: {
+        url: config.sync.url,
+        transport: config.sync.transport,
+        auth: syncAuth,
+        batchSize: config.sync.batchSize,
+        schemaVersion: config.sync.schemaVersion ?? config.schema.version,
+        scopeMap,
+        encryption: config.sync.encryption,
+        strictHandshake: config.sync.strictHandshake,
+        operationTransforms: config.sync.operationTransforms
+      },
+      emitter,
+      queueStorage: new StoreQueueStorage(adapter),
+      syncState: new StoreSyncStatePersistence(store, scopeMap),
+      encryptor
+    });
+    recordConflict = () => syncEngine?.recordConflict();
+    unsubscribeSync = emitter.on("operation:created", (event) => {
+      if (syncEngine) {
+        syncEngine.pushOperation(event.operation);
+      }
+    });
+  }
+  return {
+    store,
+    syncEngine,
+    unsubscribeSync,
+    unsubscribeAudit,
+    authBinding
+  };
+}
+
+// src/sequences-accessor.ts
+function createSequencesAccessor(ready, getStore) {
+  const requireStore = async () => {
+    await ready;
+    const store = getStore();
+    if (!store) {
+      throw new Error("Store not initialized. Await app.ready before using sequences.");
     }
+    return store;
   };
-  const unsubs = [];
-  for (const type of SYNC_STATUS_EVENT_TYPES) {
-    unsubs.push(emitter.on(type, refresh));
-  }
-  const bridge = {
-    get status() {
-      return currentStatus;
+  return {
+    async next(name, config) {
+      const store = await requireStore();
+      return store.getSequenceManager().next(name, config);
     },
-    subscribe(listener) {
-      listeners.add(listener);
-      listener(currentStatus);
-      return () => {
-        listeners.delete(listener);
-      };
+    async current(name, config) {
+      const store = await requireStore();
+      return store.getSequenceManager().current(name, config);
     },
-    refresh,
-    destroy() {
-      for (const unsub of unsubs) {
-        unsub();
-      }
-      unsubs.length = 0;
-      listeners.clear();
+    async reset(name, config) {
+      const store = await requireStore();
+      return store.getSequenceManager().reset(name, config);
     }
   };
-  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).'
-      }
-    );
+// src/setup-devtools.ts
+var import_devtools = require("@korajs/devtools");
+function setupDevtools(config, emitter) {
+  if (!config.devtools) {
+    return { instrumenter: null, destroyOverlay: null };
   }
-}
-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" }.'
+  const instrumenter = new import_devtools.Instrumenter(emitter, {
+    bridgeEnabled: typeof globalThis !== "undefined" && "window" in globalThis
+  });
+  let destroyOverlay = null;
+  if (typeof globalThis !== "undefined" && "window" in globalThis) {
+    void import("@korajs/devtools/overlay").then(({ mountKoraDevtoolsOverlay }) => {
+      destroyOverlay = mountKoraDevtoolsOverlay(instrumenter);
+    }).catch(() => {
     });
   }
-  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."
-      }
-    );
-  }
+  return { instrumenter, destroyOverlay: () => destroyOverlay?.() };
 }
 
-// src/create-app.ts
-function createApp(config) {
-  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(() => {
-      });
-    }
+// src/sync-control.ts
+var import_sync4 = require("@korajs/sync");
+function createSyncControl(options) {
+  const { config, ready, state } = options;
+  if (!config.sync) {
+    return null;
   }
-  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_sync2.ConnectionMonitor();
-      reconnectionManager = new import_sync2.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;
-        }
-      });
-      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 || engine.isSchemaBlocked()) 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);
-          });
-        });
-      }
-      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 ? {
+  const offlineSyncStatus = () => import_sync4.OFFLINE_SYNC_STATUS;
+  const bridgeStatus = () => state.syncStatusBridge?.status ?? offlineSyncStatus();
+  return {
     get status() {
-      return syncStatusBridge?.status ?? offlineSyncStatus();
+      return bridgeStatus();
     },
     subscribeStatus(listener) {
-      if (syncStatusBridge) {
-        return syncStatusBridge.subscribe(listener);
+      if (state.syncStatusBridge) {
+        return state.syncStatusBridge.subscribe(listener);
       }
       listener(offlineSyncStatus());
       return () => {
@@ -1144,41 +1047,41 @@ function createApp(config) {
     },
     async connect() {
       await ready;
-      if (syncEngine) {
-        intentionalDisconnect = false;
-        reconnectionManager?.stop();
-        reconnectionManager?.reset();
-        await syncEngine.start();
-        syncStatusBridge?.refresh();
+      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();
-        syncStatusBridge?.refresh();
+      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 offlineSyncStatus();
     },
     async retryNow() {
       await ready;
-      if (syncEngine) {
-        await syncEngine.retryNow();
+      if (state.syncEngine) {
+        await state.syncEngine.retryNow();
       }
     },
     clearSchemaBlock() {
-      syncEngine?.clearSchemaBlock();
+      state.syncEngine?.clearSchemaBlock();
     },
     exportDiagnostics() {
-      if (syncEngine) {
-        return syncEngine.exportDiagnostics();
+      if (state.syncEngine) {
+        return state.syncEngine.exportDiagnostics();
       }
       return {
         state: "disconnected",
@@ -1203,11 +1106,199 @@ function createApp(config) {
         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.");
+  };
+}
+
+// src/auth-sync-coordinator.ts
+var AuthSyncCoordinator = class {
+  constructor(getEngine, authBinding) {
+    this.getEngine = getEngine;
+    this.authBinding = authBinding;
+  }
+  getEngine;
+  authBinding;
+  inFlight = null;
+  pending = false;
+  disposed = false;
+  scheduleReconnect() {
+    if (this.disposed) {
+      return;
+    }
+    if (this.inFlight) {
+      this.pending = true;
+      return;
+    }
+    this.inFlight = this.run().finally(() => {
+      this.inFlight = null;
+      if (this.pending && !this.disposed) {
+        this.pending = false;
+        this.scheduleReconnect();
+      }
+    });
+  }
+  destroy() {
+    this.disposed = true;
+    this.pending = false;
+  }
+  async run() {
+    const engine = this.getEngine();
+    if (!engine) {
+      return;
+    }
+    const headers = await this.authBinding.auth();
+    if (!headers.token) {
+      await engine.stop();
+      return;
+    }
+    if (this.authBinding.resolveScopeMap) {
+      const nextScope = await this.authBinding.resolveScopeMap();
+      engine.updateScope(nextScope);
+    }
+    const status = engine.getStatus().status;
+    if (status !== "offline") {
+      await engine.stop();
+    }
+    await engine.start();
+  }
+};
+
+// src/sync-status-bridge.ts
+var import_sync5 = require("@korajs/sync");
+function createSyncStatusBridge(emitter, getSyncEngine) {
+  const controller = (0, import_sync5.createSyncStatusController)({
+    getSyncEngine,
+    subscribeSyncStatus: null,
+    events: emitter
+  });
+  return {
+    get status() {
+      return controller.getSnapshot();
+    },
+    subscribe(listener) {
+      return controller.subscribe(() => {
+        listener(controller.getSnapshot());
+      });
+    },
+    refresh: () => controller.refresh(),
+    destroy: () => controller.destroy()
+  };
+}
+
+// src/sync-lifecycle.ts
+var import_sync6 = require("@korajs/sync");
+function wireSyncLifecycleAfterReady(config, emitter, state, init) {
+  state.syncEngine = init.syncEngine;
+  if (!config.sync) {
+    return;
+  }
+  state.syncStatusBridge = createSyncStatusBridge(emitter, () => state.syncEngine);
+  state.syncStatusBridge.refresh();
+  if (state.syncEngine && init.authBinding?.subscribe) {
+    state.authSyncCoordinator = new AuthSyncCoordinator(() => state.syncEngine, init.authBinding);
+    init.authBinding.subscribe(() => {
+      state.authSyncCoordinator?.scheduleReconnect();
+    });
+  }
+  if (!state.syncEngine) {
+    return;
+  }
+  const syncEngine = state.syncEngine;
+  state.connectionMonitor = new import_sync6.ConnectionMonitor();
+  state.reconnectionManager = new import_sync6.ReconnectionManager({
+    initialDelay: config.sync.reconnectInterval,
+    maxDelay: config.sync.maxReconnectInterval
+  });
+  emitter.on("sync:sent", () => state.connectionMonitor?.recordActivity());
+  emitter.on("sync:received", () => state.connectionMonitor?.recordActivity());
+  emitter.on("sync:acknowledged", () => state.connectionMonitor?.recordActivity());
+  emitter.on("sync:connected", () => {
+    if (state.qualityInterval !== null) {
+      clearInterval(state.qualityInterval);
+    }
+    state.qualityInterval = setInterval(() => {
+      if (state.connectionMonitor) {
+        emitter.emit({
+          type: "connection:quality",
+          quality: state.connectionMonitor.getQuality()
+        });
+      }
+    }, 5e3);
+  });
+  emitter.on("sync:disconnected", () => {
+    state.connectionMonitor?.reset();
+    if (state.qualityInterval !== null) {
+      clearInterval(state.qualityInterval);
+      state.qualityInterval = null;
+    }
+  });
+  const browserGlobal = globalThis;
+  if (typeof browserGlobal.addEventListener === "function") {
+    const onOnline = () => {
+      if (state.intentionalDisconnect || config.sync?.autoReconnect === false) {
+        return;
+      }
+      state.reconnectionManager?.wake();
+      state.reconnectionManager?.reset();
+      void syncEngine.retryNow();
+    };
+    browserGlobal.addEventListener("online", onOnline);
+    state.removeOnlineListener = () => {
+      browserGlobal.removeEventListener?.("online", onOnline);
+    };
+  }
+  emitter.on("sync:schema-mismatch", () => {
+    state.reconnectionManager?.stop();
+    state.intentionalDisconnect = true;
+  });
+  if (config.sync.autoReconnect !== false) {
+    emitter.on("sync:disconnected", () => {
+      if (state.intentionalDisconnect || syncEngine.isSchemaBlocked()) {
+        return;
+      }
+      if (state.reconnectionManager?.isRunning()) {
+        return;
+      }
+      syncEngine.setReconnecting(true);
+      state.reconnectionManager?.stop();
+      state.reconnectionManager?.start(async () => {
+        try {
+          await syncEngine.start();
+          syncEngine.setReconnecting(false);
+          return true;
+        } catch {
+          return false;
+        }
+      }).then(() => {
+        syncEngine.setReconnecting(false);
+      });
+    });
+  }
+  if (config.sync.autoConnect === true) {
+    void syncEngine.start().catch(() => {
+    });
+  }
+}
+function teardownSyncLifecycle(state) {
+  if (state.qualityInterval !== null) {
+    clearInterval(state.qualityInterval);
+    state.qualityInterval = null;
+  }
+  state.reconnectionManager?.stop();
+  state.syncStatusBridge?.destroy();
+  state.syncStatusBridge = null;
+  state.authSyncCoordinator?.destroy();
+  state.authSyncCoordinator = null;
+  state.removeOnlineListener?.();
+  state.removeOnlineListener = null;
+}
+
+// src/transaction-executor.ts
+function createTransactionExecutor(config, ready, getStore) {
+  return async (fn, mutationName) => {
+    await ready;
+    const store = getStore();
+    if (!store) {
+      throw new Error("Store not initialized. Await app.ready before using transactions.");
     }
     const collectionNames = Object.keys(config.schema.collections);
     return store.transaction(async (tx) => {
@@ -1226,29 +1317,130 @@ function createApp(config) {
       }
       await fn(proxy);
     });
+  };
+}
+
+// src/validate-config.ts
+var import_core5 = require("@korajs/core");
+function validateCreateAppConfig(config) {
+  if (!config.schema) {
+    throw new import_core5.SchemaValidationError("createApp requires a schema.", {
+      fix: "Pass schema: defineSchema({ version: 1, collections: { ... } })"
+    });
   }
-  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);
+  if (config.schema.version < 1) {
+    throw new import_core5.SchemaValidationError("Schema version must be at least 1.", {
+      version: config.schema.version
+    });
+  }
+  const collectionNames = Object.keys(config.schema.collections);
+  if (collectionNames.length === 0) {
+    throw new import_core5.SchemaValidationError("Schema must define at least one collection.", {
+      fix: "Add entries under collections in defineSchema()."
+    });
+  }
+  if (config.sync) {
+    validateSyncUrl(config.sync.url, config.sync.transport ?? "websocket");
+  }
+  const adapter = config.store?.adapter ?? detectAdapterType();
+  const isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+  if (isBrowser && (adapter === "sqlite-wasm" || adapter === "indexeddb") && !config.store?.workerUrl) {
+    throw new import_core5.KoraError(
+      "Browser storage requires store.workerUrl pointing to the SQLite WASM worker script.",
+      "MISSING_WORKER_URL",
+      {
+        adapter,
+        fix: 'Add store: { workerUrl: "/sqlite-wasm-worker.js" } (see create-kora-app templates).'
+      }
+    );
+  }
+}
+function validateSyncUrl(url, transport) {
+  if (!url || url.trim().length === 0) {
+    throw new import_core5.KoraError("sync.url is required when sync is configured.", "INVALID_SYNC_URL", {
+      fix: 'Pass sync: { url: "wss://your-server/kora" }.'
+    });
+  }
+  try {
+    const parsed = new URL(url);
+    if (transport === "http") {
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("bad protocol");
+      }
+    } else if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+      throw new Error("bad protocol");
     }
+  } catch {
+    throw new import_core5.KoraError(
+      `Invalid sync URL "${url}" for transport "${transport}".`,
+      "INVALID_SYNC_URL",
+      {
+        url,
+        transport,
+        fix: transport === "http" ? "Use an absolute http:// or https:// URL." : "Use an absolute ws:// or wss:// URL."
+      }
+    );
+  }
+}
+
+// src/wire-sync-event-forwarding.ts
+var SYNC_EVENT_TYPES = [
+  "sync:connected",
+  "sync:disconnected",
+  "sync:schema-mismatch",
+  "sync:auth-failed",
+  "sync:sent",
+  "sync:received",
+  "sync:acknowledged",
+  "sync:apply-failed",
+  "sync:diagnostics",
+  "sync:bandwidth",
+  "sync:initial-sync-progress"
+];
+function wireSyncEventForwarding(emitter, handler) {
+  for (const type of SYNC_EVENT_TYPES) {
+    emitter.on(type, (event) => {
+      handler(event);
+    });
+  }
+}
+
+// src/create-app.ts
+function createApp(config) {
+  validateCreateAppConfig(config);
+  const emitter = new import_internal5.SimpleEventEmitter();
+  const mergeEngine = new import_merge2.MergeEngine();
+  if (config.onSyncEvent) {
+    wireSyncEventForwarding(emitter, config.onSyncEvent);
+  }
+  let store = null;
+  let unsubscribeSync = null;
+  let unsubscribeAudit = null;
+  const syncState = {
+    syncEngine: null,
+    syncStatusBridge: null,
+    authSyncCoordinator: null,
+    reconnectionManager: null,
+    connectionMonitor: null,
+    qualityInterval: null,
+    intentionalDisconnect: false,
+    removeOnlineListener: null
   };
+  const devtools = setupDevtools(config, emitter);
+  const queryStoreCache = new import_store5.QueryStoreCache(config.store?.name ?? "kora-db");
+  const ready = initializeApp(config, emitter, mergeEngine).then((init) => {
+    store = init.store;
+    unsubscribeSync = init.unsubscribeSync;
+    unsubscribeAudit = init.unsubscribeAudit;
+    wireSyncLifecycleAfterReady(config, emitter, syncState, init);
+  });
+  const getStore = () => store;
+  const executeTransaction = createTransactionExecutor(config, ready, getStore);
   const app = {
     ready,
     events: emitter,
-    sync: syncControl,
-    sequences,
+    sync: createSyncControl({ config, ready, state: syncState }),
+    sequences: createSequencesAccessor(ready, getStore),
     getStore() {
       if (!store) {
         throw new Error("Store not initialized. Await app.ready before accessing the store.");
@@ -1256,30 +1448,23 @@ 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 (destroyDevtoolsOverlay) {
-        destroyDevtoolsOverlay();
-        destroyDevtoolsOverlay = null;
-      }
-      if (instrumenter) {
-        instrumenter.destroy();
-        instrumenter = null;
-      }
+      syncState.intentionalDisconnect = true;
+      teardownSyncLifecycle(syncState);
+      devtools.destroyOverlay?.();
+      devtools.instrumenter?.destroy();
       if (unsubscribeSync) {
         unsubscribeSync();
         unsubscribeSync = null;
@@ -1288,14 +1473,11 @@ function createApp(config) {
         unsubscribeAudit();
         unsubscribeAudit = null;
       }
-      if (syncEngine) {
-        await syncEngine.stop();
-        syncEngine = null;
-      }
-      if (syncStatusBridge) {
-        syncStatusBridge.destroy();
-        syncStatusBridge = null;
+      if (syncState.syncEngine) {
+        await syncState.syncEngine.stop();
+        syncState.syncEngine = null;
       }
+      queryStoreCache.clear();
       if (store) {
         await store.close();
         store = null;
@@ -1334,7 +1516,7 @@ function createApp(config) {
   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
@@ -1342,190 +1524,23 @@ function createApp(config) {
   }
   return app;
 }
-async function initializeAsync(config, emitter, mergeEngine) {
-  const adapterType = config.store?.adapter ?? detectAdapterType();
-  const dbName = config.store?.name ?? "kora-db";
-  const adapter = await createAdapter(
-    adapterType,
-    dbName,
-    config.store?.workerUrl,
-    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,
-    dbName,
-    nodeId: authNodeId,
-    isolation: authNodeId ? "shared" : config.store?.isolation,
-    ...config.sync ? { onQuerySubscribed: createSyncQuerySubscriptionHook(() => syncEngine) } : {}
-  });
-  await store.open();
-  let recordConflict;
-  const applyPipeline = new ApplyPipeline({
-    store,
-    mergeEngine,
-    emitter,
-    onMergeConflict: () => recordConflict?.()
-  });
-  store.setLocalMutationHandler(applyPipeline);
-  const unsubscribeAudit = wireAuditPersistence(store, emitter);
-  let unsubscribeSync = null;
-  if (config.sync) {
-    const transport = createSyncTransport(config.sync);
-    const mergeAwareStore = new MergeAwareSyncStore(store, mergeEngine, emitter, {
-      onMergeConflict: () => recordConflict?.()
-    });
-    let scopeMap = config.sync.scope ? (0, import_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: 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: 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 {
-    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() {
-      throw new AppNotReadyError(
-        "Cannot execute a query before app.ready. Await app.ready or use <KoraProvider app={app}>."
-      );
-    },
-    async count() {
-      throw new AppNotReadyError(
-        "Cannot count query results before app.ready. Await app.ready or use <KoraProvider app={app}>."
-      );
-    },
-    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] };
-    }
-  };
-  return builder;
-}
 
 // src/index.ts
-var import_store5 = require("@korajs/store");
+var import_store6 = 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_store9 = require("@korajs/store");
 var import_merge3 = require("@korajs/merge");
-var import_sync3 = require("@korajs/sync");
+var import_sync7 = require("@korajs/sync");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AppNotReadyError,
   HybridLogicalClock,
   KoraError,
   MergeEngine,