@anfenn/dync 1.0.0

package/dist/react/index.cjs

@@ -0,0 +1,1754 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  makeDync: () => makeDync
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/useDync.ts
+var import_react = require("react");
+
+// src/logger.ts
+function newLogger(base, min) {
+  const order = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    none: 100
+  };
+  const threshold = order[min];
+  const enabled = (lvl) => order[lvl] >= threshold;
+  return {
+    debug: (...a) => enabled("debug") && base.debug?.(...a),
+    info: (...a) => enabled("info") && base.info?.(...a),
+    warn: (...a) => enabled("warn") && base.warn?.(...a),
+    error: (...a) => enabled("error") && base.error?.(...a)
+  };
+}
+
+// src/types.ts
+var SERVER_PK = "id";
+var LOCAL_PK = "_localId";
+var UPDATED_AT = "updated_at";
+
+// src/createLocalId.ts
+function createLocalId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  throw new Error("createLocalId(): crypto.randomUUID is not available");
+}
+
+// src/helpers.ts
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+function orderFor(a) {
+  switch (a) {
+    case "create" /* Create */:
+      return 1;
+    case "update" /* Update */:
+      return 2;
+    case "remove" /* Remove */:
+      return 3;
+  }
+}
+function omitFields(item, fields) {
+  const result = { ...item };
+  for (const k of fields) delete result[k];
+  return result;
+}
+function deleteKeyIfEmptyObject(obj, key) {
+  if (obj[key] && Object.keys(obj[key]).length === 0) {
+    delete obj[key];
+  }
+}
+
+// src/addVisibilityChangeListener.ts
+function addVisibilityChangeListener(add, currentSubscription, onVisibilityChange) {
+  if (add && !currentSubscription) {
+    const handler = () => {
+      onVisibilityChange(document.visibilityState === "visible");
+    };
+    document.addEventListener("visibilitychange", handler);
+    return {
+      remove: () => {
+        document.removeEventListener("visibilitychange", handler);
+      }
+    };
+  } else if (!add && currentSubscription) {
+    currentSubscription.remove();
+    return void 0;
+  }
+  return currentSubscription;
+}
+
+// src/core/StateManager.ts
+var LOCAL_ONLY_SYNC_FIELDS = [LOCAL_PK, UPDATED_AT];
+var DYNC_STATE_TABLE = "_dync_state";
+var SYNC_STATE_KEY = "sync_state";
+var DEFAULT_STATE = {
+  firstLoadDone: false,
+  pendingChanges: [],
+  lastPulled: {}
+};
+var StateManager = class {
+  persistedState;
+  syncStatus;
+  listeners = /* @__PURE__ */ new Set();
+  storageAdapter;
+  hydrated = false;
+  constructor(ctx) {
+    this.storageAdapter = ctx.storageAdapter;
+    this.persistedState = DEFAULT_STATE;
+    this.syncStatus = ctx.initialStatus ?? "disabled";
+  }
+  /**
+   * Load state from the database. Called after stores() defines the schema.
+   */
+  async hydrate() {
+    if (this.hydrated) return;
+    if (!this.storageAdapter) {
+      throw new Error("Cannot hydrate state without a storage adapter");
+    }
+    const table = this.storageAdapter.table(DYNC_STATE_TABLE);
+    const row = await table.get(SYNC_STATE_KEY);
+    if (row?.value) {
+      this.persistedState = parseStoredState(row.value);
+    }
+    this.hydrated = true;
+    this.emit();
+  }
+  emit() {
+    this.listeners.forEach((fn) => fn(this.getSyncState()));
+  }
+  async persist() {
+    if (!this.hydrated || !this.storageAdapter) return;
+    this.emit();
+    const table = this.storageAdapter.table(DYNC_STATE_TABLE);
+    await table.put({ [LOCAL_PK]: SYNC_STATE_KEY, value: JSON.stringify(this.persistedState) });
+  }
+  getState() {
+    return clonePersistedState(this.persistedState);
+  }
+  setState(setterOrState) {
+    this.persistedState = resolveNextState(this.persistedState, setterOrState);
+    return this.persist();
+  }
+  /**
+   * Set error in memory only without persisting to database.
+   * Used when the database itself failed to open.
+   */
+  setErrorInMemory(error) {
+    this.persistedState = { ...this.persistedState, error };
+    this.emit();
+  }
+  addPendingChange(change) {
+    const next = clonePersistedState(this.persistedState);
+    const queueItem = next.pendingChanges.find((p) => p.localId === change.localId && p.stateKey === change.stateKey);
+    const omittedChanges = omitFields(change.changes, LOCAL_ONLY_SYNC_FIELDS);
+    const omittedBefore = omitFields(change.before, LOCAL_ONLY_SYNC_FIELDS);
+    const omittedAfter = omitFields(change.after, LOCAL_ONLY_SYNC_FIELDS);
+    const hasChanges = Object.keys(omittedChanges || {}).length > 0;
+    const action = change.action;
+    if (queueItem) {
+      if (queueItem.action === "remove" /* Remove */) {
+        return Promise.resolve();
+      }
+      queueItem.version += 1;
+      if (action === "remove" /* Remove */) {
+        queueItem.action = "remove" /* Remove */;
+      } else if (hasChanges) {
+        queueItem.changes = { ...queueItem.changes, ...omittedChanges };
+        queueItem.after = { ...queueItem.after, ...omittedAfter };
+      }
+    } else if (action === "remove" /* Remove */ || hasChanges) {
+      next.pendingChanges = [...next.pendingChanges];
+      next.pendingChanges.push({
+        action,
+        stateKey: change.stateKey,
+        localId: change.localId,
+        id: change.id,
+        version: 1,
+        changes: omittedChanges,
+        before: omittedBefore,
+        after: omittedAfter
+      });
+    }
+    this.persistedState = next;
+    return this.persist();
+  }
+  samePendingVersion(stateKey, localId, version) {
+    return this.persistedState.pendingChanges.find((p) => p.localId === localId && p.stateKey === stateKey)?.version === version;
+  }
+  removePendingChange(localId, stateKey) {
+    const next = clonePersistedState(this.persistedState);
+    next.pendingChanges = next.pendingChanges.filter((p) => !(p.localId === localId && p.stateKey === stateKey));
+    this.persistedState = next;
+    return this.persist();
+  }
+  updatePendingChange(stateKey, localId, action, id) {
+    const next = clonePersistedState(this.persistedState);
+    const changeItem = next.pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localId);
+    if (changeItem) {
+      changeItem.action = action;
+      if (id) changeItem.id = id;
+      this.persistedState = next;
+      return this.persist();
+    }
+    return Promise.resolve();
+  }
+  setPendingChangeBefore(stateKey, localId, before) {
+    const next = clonePersistedState(this.persistedState);
+    const changeItem = next.pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localId);
+    if (changeItem) {
+      changeItem.before = { ...changeItem.before ?? {}, ...before };
+      this.persistedState = next;
+      return this.persist();
+    }
+    return Promise.resolve();
+  }
+  hasConflicts(localId) {
+    return Boolean(this.persistedState.conflicts?.[localId]);
+  }
+  getSyncStatus() {
+    return this.syncStatus;
+  }
+  setSyncStatus(status) {
+    if (this.syncStatus === status) return;
+    this.syncStatus = status;
+    this.emit();
+  }
+  getSyncState() {
+    return buildSyncState(this.persistedState, this.syncStatus, this.hydrated);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+};
+function parseStoredState(stored) {
+  const parsed = JSON.parse(stored);
+  if (parsed.pendingChanges) {
+    parsed.pendingChanges = parsed.pendingChanges.map((change) => ({
+      ...change,
+      timestamp: change.timestamp ? new Date(change.timestamp) : change.timestamp
+    }));
+  }
+  return parsed;
+}
+function resolveNextState(current, setterOrState) {
+  if (typeof setterOrState === "function") {
+    return { ...current, ...setterOrState(clonePersistedState(current)) };
+  }
+  return { ...current, ...setterOrState };
+}
+function buildSyncState(state, status, hydrated) {
+  const persisted = clonePersistedState(state);
+  const syncState = {
+    ...persisted,
+    status,
+    hydrated
+  };
+  deleteKeyIfEmptyObject(syncState, "conflicts");
+  return syncState;
+}
+function clonePersistedState(state) {
+  return {
+    ...state,
+    pendingChanges: state.pendingChanges.map((change) => ({
+      ...change,
+      changes: cloneRecord(change.changes),
+      before: cloneRecord(change.before),
+      after: cloneRecord(change.after)
+    })),
+    lastPulled: { ...state.lastPulled },
+    conflicts: cloneConflicts(state.conflicts)
+  };
+}
+function cloneConflicts(conflicts) {
+  if (!conflicts) return void 0;
+  const next = {};
+  for (const [key, value] of Object.entries(conflicts)) {
+    next[key] = {
+      stateKey: value.stateKey,
+      fields: value.fields.map((field) => ({ ...field }))
+    };
+  }
+  return next;
+}
+function cloneRecord(record) {
+  if (!record) return record;
+  return { ...record };
+}
+
+// src/core/tableEnhancers.ts
+function wrapWithMutationEmitter(table, tableName, emitMutation) {
+  const rawAdd = table.raw.add;
+  const rawPut = table.raw.put;
+  const rawUpdate = table.raw.update;
+  const rawDelete = table.raw.delete;
+  const rawBulkAdd = table.raw.bulkAdd;
+  const rawBulkPut = table.raw.bulkPut;
+  const rawBulkUpdate = table.raw.bulkUpdate;
+  const rawBulkDelete = table.raw.bulkDelete;
+  const rawClear = table.raw.clear;
+  table.add = async (item) => {
+    const result = await rawAdd(item);
+    emitMutation({ type: "add", tableName, keys: [result] });
+    return result;
+  };
+  table.put = async (item) => {
+    const result = await rawPut(item);
+    emitMutation({ type: "update", tableName, keys: [result] });
+    return result;
+  };
+  table.update = async (key, changes) => {
+    const result = await rawUpdate(key, changes);
+    if (result > 0) {
+      emitMutation({ type: "update", tableName, keys: [key] });
+    }
+    return result;
+  };
+  table.delete = async (key) => {
+    await rawDelete(key);
+    emitMutation({ type: "delete", tableName, keys: [key] });
+  };
+  table.bulkAdd = async (items) => {
+    const result = await rawBulkAdd(items);
+    if (items.length > 0) {
+      emitMutation({ type: "add", tableName });
+    }
+    return result;
+  };
+  table.bulkPut = async (items) => {
+    const result = await rawBulkPut(items);
+    if (items.length > 0) {
+      emitMutation({ type: "update", tableName });
+    }
+    return result;
+  };
+  table.bulkUpdate = async (keysAndChanges) => {
+    const result = await rawBulkUpdate(keysAndChanges);
+    if (result > 0) {
+      emitMutation({ type: "update", tableName, keys: keysAndChanges.map((kc) => kc.key) });
+    }
+    return result;
+  };
+  table.bulkDelete = async (keys) => {
+    await rawBulkDelete(keys);
+    if (keys.length > 0) {
+      emitMutation({ type: "delete", tableName });
+    }
+  };
+  table.clear = async () => {
+    await rawClear();
+    emitMutation({ type: "delete", tableName });
+  };
+}
+function setupEnhancedTables({ owner, tableCache, enhancedTables, getTable }, tableNames) {
+  for (const tableName of tableNames) {
+    tableCache.delete(tableName);
+    enhancedTables.delete(tableName);
+    if (!Object.prototype.hasOwnProperty.call(owner, tableName)) {
+      Object.defineProperty(owner, tableName, {
+        get: () => getTable(tableName),
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+}
+function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTables, emitMutation }) {
+  const rawAdd = table.raw.add;
+  const rawPut = table.raw.put;
+  const rawUpdate = table.raw.update;
+  const rawDelete = table.raw.delete;
+  const rawBulkAdd = table.raw.bulkAdd;
+  const rawBulkPut = table.raw.bulkPut;
+  const rawBulkUpdate = table.raw.bulkUpdate;
+  const rawBulkDelete = table.raw.bulkDelete;
+  const rawClear = table.raw.clear;
+  const wrappedAdd = async (item) => {
+    let localId = item._localId;
+    if (!localId) localId = createLocalId();
+    const syncedItem = {
+      ...item,
+      _localId: localId,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let result;
+    await withTransaction("rw", [tableName, DYNC_STATE_TABLE], async () => {
+      result = await rawAdd(syncedItem);
+      await state.addPendingChange({
+        action: "create" /* Create */,
+        stateKey: tableName,
+        localId,
+        changes: syncedItem,
+        before: null,
+        after: syncedItem
+      });
+    });
+    emitMutation({ type: "add", tableName, keys: [localId] });
+    return result;
+  };
+  const wrappedPut = async (item) => {
+    let localId = item._localId;
+    if (!localId) localId = createLocalId();
+    const syncedItem = {
+      ...item,
+      _localId: localId,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let result;
+    let isUpdate = false;
+    let existingRecord;
+    await withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+      const txTable = tables[tableName];
+      existingRecord = await txTable.get(localId);
+      isUpdate = !!existingRecord;
+      result = await rawPut(syncedItem);
+      await state.addPendingChange({
+        action: isUpdate ? "update" /* Update */ : "create" /* Create */,
+        stateKey: tableName,
+        localId,
+        id: existingRecord?.id,
+        changes: syncedItem,
+        before: existingRecord ?? null,
+        after: syncedItem
+      });
+    });
+    emitMutation({ type: isUpdate ? "update" : "add", tableName, keys: [localId] });
+    return result;
+  };
+  const wrappedUpdate = async (key, changes) => {
+    const updatedChanges = {
+      ...changes,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let result = 0;
+    await withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+      const txTable = tables[tableName];
+      const record = await txTable.get(key);
+      if (!record) {
+        throw new Error(`Record with key=${key} not found`);
+      }
+      result = await rawUpdate(key, updatedChanges) ?? 0;
+      if (result > 0) {
+        await state.addPendingChange({
+          action: "update" /* Update */,
+          stateKey: tableName,
+          localId: key,
+          id: record.id,
+          changes: updatedChanges,
+          before: record,
+          after: { ...record, ...updatedChanges }
+        });
+      }
+    });
+    if (result > 0) {
+      emitMutation({ type: "update", tableName, keys: [key] });
+    }
+    return result;
+  };
+  const wrappedDelete = async (key) => {
+    let deletedLocalId;
+    await withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+      const txTable = tables[tableName];
+      const record = await txTable.get(key);
+      await rawDelete(key);
+      if (record) {
+        deletedLocalId = record._localId;
+        await state.addPendingChange({
+          action: "remove" /* Remove */,
+          stateKey: tableName,
+          localId: record._localId,
+          id: record.id,
+          changes: null,
+          before: record
+        });
+      }
+    });
+    if (deletedLocalId) {
+      emitMutation({ type: "delete", tableName, keys: [deletedLocalId] });
+    }
+  };
+  const wrappedBulkAdd = async (items) => {
+    if (items.length === 0) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const syncedItems = items.map((item) => {
+      const localId = item._localId || createLocalId();
+      return {
+        ...item,
+        _localId: localId,
+        updated_at: now
+      };
+    });
+    let result;
+    await withTransaction("rw", [tableName, DYNC_STATE_TABLE], async () => {
+      result = await rawBulkAdd(syncedItems);
+      for (const syncedItem of syncedItems) {
+        await state.addPendingChange({
+          action: "create" /* Create */,
+          stateKey: tableName,
+          localId: syncedItem._localId,
+          changes: syncedItem,
+          before: null,
+          after: syncedItem
+        });
+      }
+    });
+    emitMutation({ type: "add", tableName, keys: syncedItems.map((i) => i._localId) });
+    return result;
+  };
+  const wrappedBulkPut = async (items) => {
+    if (items.length === 0) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const syncedItems = items.map((item) => {
+      const localId = item._localId || createLocalId();
+      return {
+        ...item,
+        _localId: localId,
+        updated_at: now
+      };
+    });
+    const localIds = syncedItems.map((i) => i._localId);
+    let result;
+    await withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+      const txTable = tables[tableName];
+      const existingRecords = await txTable.bulkGet(localIds);
+      const existingMap = /* @__PURE__ */ new Map();
+      for (let i = 0; i < localIds.length; i++) {
+        if (existingRecords[i]) {
+          existingMap.set(localIds[i], existingRecords[i]);
+        }
+      }
+      result = await rawBulkPut(syncedItems);
+      for (const syncedItem of syncedItems) {
+        const existing = existingMap.get(syncedItem._localId);
+        await state.addPendingChange({
+          action: existing ? "update" /* Update */ : "create" /* Create */,
+          stateKey: tableName,
+          localId: syncedItem._localId,
+          id: existing?.id,
+          changes: syncedItem,
+          before: existing ?? null,
+          after: syncedItem
+        });
+      }
+    });
+    emitMutation({ type: "update", tableName, keys: localIds });
+    return result;
+  };
+  const wrappedBulkUpdate = async (keysAndChanges) => {
+    if (keysAndChanges.length === 0) return 0;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updatedKeysAndChanges = keysAndChanges.map(({ key, changes }) => ({
+      key,
+      changes: {
+        ...changes,
+        updated_at: now
+      }
+    }));
+    let result = 0;
+    const updatedKeys = [];
+    await withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+      const txTable = tables[tableName];
+      const keys = updatedKeysAndChanges.map((kc) => kc.key);
+      const records = await txTable.bulkGet(keys);
+      const recordMap = /* @__PURE__ */ new Map();
+      for (let i = 0; i < keys.length; i++) {
+        if (records[i]) {
+          recordMap.set(String(keys[i]), records[i]);
+        }
+      }
+      result = await rawBulkUpdate(updatedKeysAndChanges);
+      for (const { key, changes } of updatedKeysAndChanges) {
+        const record = recordMap.get(String(key));
+        if (record) {
+          updatedKeys.push(record._localId);
+          await state.addPendingChange({
+            action: "update" /* Update */,
+            stateKey: tableName,
+            localId: record._localId,
+            id: record.id,
+            changes,
+            before: record,
+            after: { ...record, ...changes }
+          });
+        }
+      }
+    });
+    if (updatedKeys.length > 0) {
+      emitMutation({ type: "update", tableName, keys: updatedKeys });
+    }
+    return result;
+  };
+  const wrappedBulkDelete = async (keys) => {
+    if (keys.length === 0) return;
+    const deletedLocalIds = [];
+    await withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+      const txTable = tables[tableName];
+      const records = await txTable.bulkGet(keys);
+      await rawBulkDelete(keys);
+      for (const record of records) {
+        if (record) {
+          deletedLocalIds.push(record._localId);
+          await state.addPendingChange({
+            action: "remove" /* Remove */,
+            stateKey: tableName,
+            localId: record._localId,
+            id: record.id,
+            changes: null,
+            before: record
+          });
+        }
+      }
+    });
+    if (deletedLocalIds.length > 0) {
+      emitMutation({ type: "delete", tableName, keys: deletedLocalIds });
+    }
+  };
+  const wrappedClear = async () => {
+    const deletedLocalIds = [];
+    await withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+      const txTable = tables[tableName];
+      const allRecords = await txTable.toArray();
+      await rawClear();
+      for (const record of allRecords) {
+        if (record._localId) {
+          deletedLocalIds.push(record._localId);
+          await state.addPendingChange({
+            action: "remove" /* Remove */,
+            stateKey: tableName,
+            localId: record._localId,
+            id: record.id,
+            changes: null,
+            before: record
+          });
+        }
+      }
+    });
+    if (deletedLocalIds.length > 0) {
+      emitMutation({ type: "delete", tableName, keys: deletedLocalIds });
+    }
+  };
+  table.add = wrappedAdd;
+  table.put = wrappedPut;
+  table.update = wrappedUpdate;
+  table.delete = wrappedDelete;
+  table.bulkAdd = wrappedBulkAdd;
+  table.bulkPut = wrappedBulkPut;
+  table.bulkUpdate = wrappedBulkUpdate;
+  table.bulkDelete = wrappedBulkDelete;
+  table.clear = wrappedClear;
+  enhancedTables.add(tableName);
+}
+
+// src/core/pullOperations.ts
+async function pullAll(ctx) {
+  let firstSyncError;
+  const changedTables = [];
+  for (const [stateKey, api] of Object.entries(ctx.syncApis)) {
+    try {
+      const lastPulled = ctx.state.getState().lastPulled[stateKey];
+      const since = lastPulled ? new Date(lastPulled) : /* @__PURE__ */ new Date(0);
+      ctx.logger.debug(`[dync] pull:start stateKey=${stateKey} since=${since.toISOString()}`);
+      const serverData = await api.list(since);
+      const changed = await processPullData(stateKey, serverData, since, ctx);
+      if (changed) changedTables.push(stateKey);
+    } catch (err) {
+      firstSyncError = firstSyncError ?? err;
+      ctx.logger.error(`[dync] pull:error stateKey=${stateKey}`, err);
+    }
+  }
+  return { error: firstSyncError, changedTables };
+}
+async function handleRemoteItemUpdate(table, stateKey, localItem, remote, ctx) {
+  const pendingChange = ctx.state.getState().pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localItem._localId);
+  const conflictStrategy = ctx.conflictResolutionStrategy;
+  if (pendingChange) {
+    ctx.logger.debug(`[dync] pull:conflict-strategy:${conflictStrategy} stateKey=${stateKey} id=${remote.id}`);
+    switch (conflictStrategy) {
+      case "local-wins":
+        break;
+      case "remote-wins": {
+        const merged = { ...remote, _localId: localItem._localId };
+        await table.raw.update(localItem._localId, merged);
+        await ctx.state.removePendingChange(localItem._localId, stateKey);
+        break;
+      }
+      case "try-shallow-merge": {
+        const changes = pendingChange.changes || {};
+        const before = pendingChange.before || {};
+        const fields = Object.entries(changes).filter(([k, localValue]) => k in before && k in remote && before[k] !== remote[k] && localValue !== remote[k]).map(([key, localValue]) => ({ key, localValue, remoteValue: remote[key] }));
+        if (fields.length > 0) {
+          ctx.logger.warn(`[dync] pull:${conflictStrategy}:conflicts-found`, JSON.stringify(fields, null, 4));
+          await ctx.state.setState((syncState) => ({
+            ...syncState,
+            conflicts: {
+              ...syncState.conflicts || {},
+              [localItem._localId]: { stateKey, fields }
+            }
+          }));
+        } else {
+          const localChangedKeys = Object.keys(changes);
+          const preservedLocal = { _localId: localItem._localId };
+          for (const k of localChangedKeys) {
+            if (k in localItem) preservedLocal[k] = localItem[k];
+          }
+          const merged = { ...remote, ...preservedLocal };
+          await table.raw.update(localItem._localId, merged);
+          await ctx.state.setState((syncState) => {
+            const ss = { ...syncState };
+            delete ss.conflicts?.[localItem._localId];
+            return ss;
+          });
+        }
+        break;
+      }
+    }
+  } else {
+    const merged = { ...localItem, ...remote };
+    await table.raw.update(localItem._localId, merged);
+    ctx.logger.debug(`[dync] pull:merge-remote stateKey=${stateKey} id=${remote.id}`);
+  }
+}
+async function pullAllBatch(ctx) {
+  let firstSyncError;
+  const changedTables = [];
+  try {
+    const sinceMap = {};
+    for (const tableName of ctx.batchSync.syncTables) {
+      const lastPulled = ctx.state.getState().lastPulled[tableName];
+      sinceMap[tableName] = lastPulled ? new Date(lastPulled) : /* @__PURE__ */ new Date(0);
+    }
+    ctx.logger.debug(`[dync] pull:batch:start tables=${[...ctx.batchSync.syncTables].join(",")}`, sinceMap);
+    const serverDataByTable = await ctx.batchSync.pull(sinceMap);
+    for (const [stateKey, serverData] of Object.entries(serverDataByTable)) {
+      if (!ctx.batchSync.syncTables.includes(stateKey)) {
+        ctx.logger.warn(`[dync] pull:batch:unknown-table stateKey=${stateKey}`);
+        continue;
+      }
+      try {
+        const changed = await processPullData(stateKey, serverData, sinceMap[stateKey], ctx);
+        if (changed) changedTables.push(stateKey);
+      } catch (err) {
+        firstSyncError = firstSyncError ?? err;
+        ctx.logger.error(`[dync] pull:batch:error stateKey=${stateKey}`, err);
+      }
+    }
+  } catch (err) {
+    firstSyncError = err;
+    ctx.logger.error(`[dync] pull:batch:error`, err);
+  }
+  return { error: firstSyncError, changedTables };
+}
+async function processPullData(stateKey, serverData, since, ctx) {
+  if (!serverData?.length) return false;
+  ctx.logger.debug(`[dync] pull:process stateKey=${stateKey} count=${serverData.length}`);
+  let newest = since;
+  let hasChanges = false;
+  await ctx.withTransaction("rw", [stateKey, DYNC_STATE_TABLE], async (tables) => {
+    const txTable = tables[stateKey];
+    const pendingRemovalById = new Set(
+      ctx.state.getState().pendingChanges.filter((p) => p.stateKey === stateKey && p.action === "remove" /* Remove */).map((p) => p.id)
+    );
+    for (const remote of serverData) {
+      const remoteUpdated = new Date(remote.updated_at);
+      if (remoteUpdated > newest) newest = remoteUpdated;
+      if (pendingRemovalById.has(remote.id)) {
+        ctx.logger.debug(`[dync] pull:skip-pending-remove stateKey=${stateKey} id=${remote.id}`);
+        continue;
+      }
+      const localItem = await txTable.where("id").equals(remote.id).first();
+      if (remote.deleted) {
+        if (localItem) {
+          await txTable.raw.delete(localItem._localId);
+          ctx.logger.debug(`[dync] pull:remove stateKey=${stateKey} id=${remote.id}`);
+          hasChanges = true;
+        }
+        continue;
+      }
+      delete remote.deleted;
+      if (localItem) {
+        await handleRemoteItemUpdate(txTable, stateKey, localItem, remote, ctx);
+        hasChanges = true;
+      } else {
+        const newLocalItem = { ...remote, _localId: createLocalId() };
+        await txTable.raw.add(newLocalItem);
+        ctx.logger.debug(`[dync] pull:add stateKey=${stateKey} id=${remote.id}`);
+        hasChanges = true;
+      }
+    }
+    await ctx.state.setState((syncState) => ({
+      ...syncState,
+      lastPulled: {
+        ...syncState.lastPulled,
+        [stateKey]: newest.toISOString()
+      }
+    }));
+  });
+  return hasChanges;
+}
+
+// src/core/pushOperations.ts
+async function handleRemoveSuccess(change, ctx) {
+  const { stateKey, localId, id } = change;
+  ctx.logger.debug(`[dync] push:remove:success stateKey=${stateKey} localId=${localId} id=${id}`);
+  await ctx.state.removePendingChange(localId, stateKey);
+}
+async function handleUpdateSuccess(change, ctx) {
+  const { stateKey, localId, version, changes } = change;
+  ctx.logger.debug(`[dync] push:update:success stateKey=${stateKey} localId=${localId} id=${change.id}`);
+  if (ctx.state.samePendingVersion(stateKey, localId, version)) {
+    await ctx.state.removePendingChange(localId, stateKey);
+  } else {
+    await ctx.state.setPendingChangeBefore(stateKey, localId, changes);
+  }
+}
+async function handleCreateSuccess(change, serverResult, ctx) {
+  const { stateKey, localId, version, changes, id } = change;
+  ctx.logger.debug(`[dync] push:create:success stateKey=${stateKey} localId=${localId} id=${id ?? serverResult.id}`);
+  await ctx.withTransaction("rw", [stateKey, DYNC_STATE_TABLE], async (tables) => {
+    const txTable = tables[stateKey];
+    const wasChanged = await txTable.raw.update(localId, serverResult) ?? 0;
+    if (wasChanged && ctx.state.samePendingVersion(stateKey, localId, version)) {
+      await ctx.state.removePendingChange(localId, stateKey);
+    } else {
+      const nextAction = wasChanged ? "update" /* Update */ : "remove" /* Remove */;
+      await ctx.state.updatePendingChange(stateKey, localId, nextAction, serverResult.id);
+      if (nextAction === "remove" /* Remove */) return;
+    }
+  });
+  const finalItem = { ...changes, ...serverResult, _localId: localId };
+  ctx.syncOptions.onAfterRemoteAdd?.(stateKey, finalItem);
+}
+async function pushAll(ctx) {
+  let firstSyncError;
+  const changesSnapshot = [...ctx.state.getState().pendingChanges].sort((a, b) => orderFor(a.action) - orderFor(b.action));
+  for (const change of changesSnapshot) {
+    try {
+      await pushOne(change, ctx);
+    } catch (err) {
+      firstSyncError = firstSyncError ?? err;
+      ctx.logger.error(`[dync] push:error change=${JSON.stringify(change)}`, err);
+    }
+  }
+  return firstSyncError;
+}
+async function pushOne(change, ctx) {
+  const api = ctx.syncApis[change.stateKey];
+  if (!api) return;
+  ctx.logger.debug(`[dync] push:attempt action=${change.action} stateKey=${change.stateKey} localId=${change.localId}`);
+  const { action, stateKey, localId, id, changes, after } = change;
+  switch (action) {
+    case "remove" /* Remove */:
+      if (!id) {
+        ctx.logger.warn(`[dync] push:remove:no-id stateKey=${stateKey} localId=${localId}`);
+        await ctx.state.removePendingChange(localId, stateKey);
+        return;
+      }
+      await api.remove(id);
+      await handleRemoveSuccess(change, ctx);
+      break;
+    case "update" /* Update */: {
+      if (ctx.state.hasConflicts(localId)) {
+        ctx.logger.warn(`[dync] push:update:skipping-with-conflicts stateKey=${stateKey} localId=${localId} id=${id}`);
+        return;
+      }
+      const exists = await api.update(id, changes, after);
+      if (exists) {
+        await handleUpdateSuccess(change, ctx);
+      } else {
+        await handleMissingRemoteRecord(change, ctx);
+      }
+      break;
+    }
+    case "create" /* Create */: {
+      const result = await api.add(changes);
+      if (result) {
+        await handleCreateSuccess(change, result, ctx);
+      } else {
+        ctx.logger.warn(`[dync] push:create:no-result stateKey=${stateKey} localId=${localId} id=${id}`);
+        if (ctx.state.samePendingVersion(stateKey, localId, change.version)) {
+          await ctx.state.removePendingChange(localId, stateKey);
+        }
+      }
+      break;
+    }
+  }
+}
+async function handleMissingRemoteRecord(change, ctx) {
+  const { stateKey, localId } = change;
+  const strategy = ctx.syncOptions.missingRemoteRecordDuringUpdateStrategy;
+  let localItem;
+  await ctx.withTransaction("rw", [stateKey, DYNC_STATE_TABLE], async (tables) => {
+    const txTable = tables[stateKey];
+    localItem = await txTable.get(localId);
+    if (!localItem) {
+      ctx.logger.warn(`[dync] push:missing-remote:no-local-item stateKey=${stateKey} localId=${localId}`);
+      await ctx.state.removePendingChange(localId, stateKey);
+      return;
+    }
+    switch (strategy) {
+      case "delete-local-record":
+        await txTable.raw.delete(localId);
+        ctx.logger.debug(`[dync] push:missing-remote:${strategy} stateKey=${stateKey} id=${localItem.id}`);
+        break;
+      case "insert-remote-record": {
+        const newItem = {
+          ...localItem,
+          _localId: createLocalId(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await txTable.raw.add(newItem);
+        await txTable.raw.delete(localId);
+        await ctx.state.addPendingChange({
+          action: "create" /* Create */,
+          stateKey,
+          localId: newItem._localId,
+          changes: newItem,
+          before: null
+        });
+        ctx.logger.debug(`[dync] push:missing-remote:${strategy} stateKey=${stateKey} id=${newItem.id}`);
+        break;
+      }
+      case "ignore":
+        ctx.logger.debug(`[dync] push:missing-remote:${strategy} stateKey=${stateKey} id=${localItem.id}`);
+        break;
+      default:
+        ctx.logger.error(`[dync] push:missing-remote:unknown-strategy stateKey=${stateKey} id=${localItem.id} strategy=${strategy}`);
+        break;
+    }
+    await ctx.state.removePendingChange(localId, stateKey);
+  });
+  ctx.syncOptions.onAfterMissingRemoteRecordDuringUpdate?.(strategy, localItem);
+}
+async function pushAllBatch(ctx) {
+  let firstSyncError;
+  try {
+    const changesSnapshot = [...ctx.state.getState().pendingChanges].filter((change) => ctx.batchSync.syncTables.includes(change.stateKey)).sort((a, b) => orderFor(a.action) - orderFor(b.action));
+    if (changesSnapshot.length === 0) {
+      ctx.logger.debug("[dync] push:batch:no-changes");
+      return void 0;
+    }
+    const changesToPush = changesSnapshot.filter((change) => {
+      if (change.action === "update" /* Update */ && ctx.state.hasConflicts(change.localId)) {
+        ctx.logger.warn(`[dync] push:batch:skipping-with-conflicts stateKey=${change.stateKey} localId=${change.localId}`);
+        return false;
+      }
+      return true;
+    });
+    if (changesToPush.length === 0) {
+      ctx.logger.debug("[dync] push:batch:all-skipped");
+      return void 0;
+    }
+    const payloads = changesToPush.map((change) => ({
+      table: change.stateKey,
+      action: change.action === "create" /* Create */ ? "add" : change.action === "update" /* Update */ ? "update" : "remove",
+      localId: change.localId,
+      id: change.id,
+      data: change.action === "remove" /* Remove */ ? void 0 : change.changes
+    }));
+    ctx.logger.debug(`[dync] push:batch:start count=${payloads.length}`);
+    const results = await ctx.batchSync.push(payloads);
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const result of results) {
+      resultMap.set(result.localId, result);
+    }
+    for (const change of changesToPush) {
+      const result = resultMap.get(change.localId);
+      if (!result) {
+        ctx.logger.warn(`[dync] push:batch:missing-result localId=${change.localId}`);
+        continue;
+      }
+      try {
+        await processBatchPushResult(change, result, ctx);
+      } catch (err) {
+        firstSyncError = firstSyncError ?? err;
+        ctx.logger.error(`[dync] push:batch:error localId=${change.localId}`, err);
+      }
+    }
+  } catch (err) {
+    firstSyncError = err;
+    ctx.logger.error("[dync] push:batch:error", err);
+  }
+  return firstSyncError;
+}
+async function processBatchPushResult(change, result, ctx) {
+  const { action, stateKey, localId } = change;
+  if (!result.success) {
+    if (action === "update" /* Update */) {
+      await handleMissingRemoteRecord(change, ctx);
+    } else {
+      ctx.logger.warn(`[dync] push:batch:failed stateKey=${stateKey} localId=${localId} error=${result.error}`);
+    }
+    return;
+  }
+  switch (action) {
+    case "remove" /* Remove */:
+      handleRemoveSuccess(change, ctx);
+      break;
+    case "update" /* Update */:
+      handleUpdateSuccess(change, ctx);
+      break;
+    case "create" /* Create */: {
+      const serverResult = { id: result.id };
+      if (result.updated_at) {
+        serverResult.updated_at = result.updated_at;
+      }
+      await handleCreateSuccess(change, serverResult, ctx);
+      break;
+    }
+  }
+}
+
+// src/core/firstLoad.ts
+var yieldToEventLoop = () => sleep(0);
+var WRITE_BATCH_SIZE = 200;
+async function startFirstLoad(ctx) {
+  ctx.logger.debug("[dync] Starting first load...");
+  if (ctx.state.getState().firstLoadDone) {
+    ctx.logger.debug("[dync] First load already completed");
+    return;
+  }
+  let error;
+  for (const [stateKey, api] of Object.entries(ctx.syncApis)) {
+    if (!api.firstLoad) {
+      ctx.logger.error(`[dync] firstLoad:no-api-function stateKey=${stateKey}`);
+      continue;
+    }
+    try {
+      ctx.logger.info(`[dync] firstLoad:start stateKey=${stateKey}`);
+      let lastId;
+      let isEmptyTable = true;
+      let batchCount = 0;
+      let totalInserted = 0;
+      let totalUpdated = 0;
+      while (true) {
+        const batch = await api.firstLoad(lastId);
+        if (!batch?.length) break;
+        batchCount++;
+        const { inserted, updated } = await processBatchInChunks(ctx, stateKey, batch, isEmptyTable, lastId === void 0);
+        totalInserted += inserted;
+        totalUpdated += updated;
+        if (ctx.onProgress) {
+          ctx.onProgress({
+            table: stateKey,
+            inserted: totalInserted,
+            updated: totalUpdated,
+            total: totalInserted + totalUpdated
+          });
+        }
+        if (lastId === void 0) {
+          isEmptyTable = await ctx.table(stateKey).count() === batch.length;
+        }
+        if (lastId !== void 0 && lastId === batch[batch.length - 1].id) {
+          throw new Error(`Duplicate records downloaded, stopping to prevent infinite loop`);
+        }
+        lastId = batch[batch.length - 1].id;
+        if (batchCount % 5 === 0) {
+          await yieldToEventLoop();
+        }
+      }
+      ctx.logger.info(`[dync] firstLoad:done stateKey=${stateKey} inserted=${totalInserted} updated=${totalUpdated}`);
+    } catch (err) {
+      error = error ?? err;
+      ctx.logger.error(`[dync] firstLoad:error stateKey=${stateKey}`, err);
+    }
+  }
+  await ctx.state.setState((syncState) => ({
+    ...syncState,
+    firstLoadDone: true,
+    error
+  }));
+  ctx.logger.debug("[dync] First load completed");
+}
+async function processBatchInChunks(ctx, stateKey, batch, isEmptyTable, isFirstBatch) {
+  let newest = new Date(ctx.state.getState().lastPulled[stateKey] || 0);
+  return ctx.withTransaction("rw", [stateKey, DYNC_STATE_TABLE], async (tables) => {
+    const txTable = tables[stateKey];
+    let tableIsEmpty = isEmptyTable;
+    if (isFirstBatch) {
+      const count = await txTable.count();
+      tableIsEmpty = count === 0;
+    }
+    const activeRecords = [];
+    for (const remote of batch) {
+      const remoteUpdated = new Date(remote.updated_at || 0);
+      if (remoteUpdated > newest) newest = remoteUpdated;
+      if (remote.deleted) continue;
+      delete remote.deleted;
+      remote._localId = createLocalId();
+      activeRecords.push(remote);
+    }
+    let inserted = 0;
+    let updated = 0;
+    if (tableIsEmpty) {
+      for (let i = 0; i < activeRecords.length; i += WRITE_BATCH_SIZE) {
+        const chunk = activeRecords.slice(i, i + WRITE_BATCH_SIZE);
+        await txTable.raw.bulkAdd(chunk);
+        inserted += chunk.length;
+      }
+    } else {
+      for (let i = 0; i < activeRecords.length; i += WRITE_BATCH_SIZE) {
+        const chunk = activeRecords.slice(i, i + WRITE_BATCH_SIZE);
+        const chunkResult = await processChunkWithLookup(txTable, chunk);
+        inserted += chunkResult.inserted;
+        updated += chunkResult.updated;
+      }
+    }
+    await ctx.state.setState((syncState) => ({
+      ...syncState,
+      lastPulled: {
+        ...syncState.lastPulled,
+        [stateKey]: newest.toISOString()
+      }
+    }));
+    return { inserted, updated };
+  });
+}
+async function processChunkWithLookup(txTable, chunk) {
+  const serverIds = chunk.filter((r) => r.id != null).map((r) => r.id);
+  const existingByServerId = /* @__PURE__ */ new Map();
+  if (serverIds.length > 0) {
+    const existingRecords = await txTable.where("id").anyOf(serverIds).toArray();
+    for (const existing of existingRecords) {
+      existingByServerId.set(existing.id, existing);
+    }
+  }
+  const toAdd = [];
+  let updated = 0;
+  for (const remote of chunk) {
+    const existing = remote.id != null ? existingByServerId.get(remote.id) : void 0;
+    if (existing) {
+      const merged = Object.assign({}, existing, remote, { _localId: existing._localId });
+      await txTable.raw.update(existing._localId, merged);
+      updated++;
+    } else {
+      toAdd.push(remote);
+    }
+  }
+  if (toAdd.length > 0) {
+    await txTable.raw.bulkAdd(toAdd);
+  }
+  existingByServerId.clear();
+  return { inserted: toAdd.length, updated };
+}
+async function startFirstLoadBatch(ctx) {
+  ctx.logger.debug("[dync] Starting batch first load...");
+  if (ctx.state.getState().firstLoadDone) {
+    ctx.logger.debug("[dync] First load already completed");
+    return;
+  }
+  if (!ctx.batchSync.firstLoad) {
+    ctx.logger.warn("[dync] firstLoad:batch:no-firstLoad-function");
+    await ctx.state.setState((syncState) => ({
+      ...syncState,
+      firstLoadDone: true
+    }));
+    return;
+  }
+  let error;
+  try {
+    ctx.logger.info(`[dync] firstLoad:batch:start tables=${[...ctx.batchSync.syncTables].join(",")}`);
+    const progress = {};
+    for (const tableName of ctx.batchSync.syncTables) {
+      progress[tableName] = { inserted: 0, updated: 0 };
+    }
+    let cursors = {};
+    for (const tableName of ctx.batchSync.syncTables) {
+      cursors[tableName] = void 0;
+    }
+    let batchCount = 0;
+    while (true) {
+      const result = await ctx.batchSync.firstLoad(cursors);
+      if (!result.hasMore && Object.values(result.data).every((d) => !d?.length)) {
+        break;
+      }
+      batchCount++;
+      for (const [stateKey, batch] of Object.entries(result.data)) {
+        if (!ctx.batchSync.syncTables.includes(stateKey)) {
+          ctx.logger.warn(`[dync] firstLoad:batch:unknown-table stateKey=${stateKey}`);
+          continue;
+        }
+        if (!batch?.length) continue;
+        const isFirstBatch = progress[stateKey].inserted === 0 && progress[stateKey].updated === 0;
+        const isEmptyTable = isFirstBatch && await ctx.table(stateKey).count() === 0;
+        const { inserted, updated } = await processBatchInChunks(ctx, stateKey, batch, isEmptyTable, isFirstBatch);
+        progress[stateKey].inserted += inserted;
+        progress[stateKey].updated += updated;
+        if (ctx.onProgress) {
+          ctx.onProgress({
+            table: stateKey,
+            inserted: progress[stateKey].inserted,
+            updated: progress[stateKey].updated,
+            total: progress[stateKey].inserted + progress[stateKey].updated
+          });
+        }
+      }
+      cursors = result.cursors;
+      if (batchCount % 5 === 0) {
+        await yieldToEventLoop();
+      }
+      if (!result.hasMore) {
+        break;
+      }
+    }
+    for (const [stateKey, p] of Object.entries(progress)) {
+      ctx.logger.info(`[dync] firstLoad:batch:done stateKey=${stateKey} inserted=${p.inserted} updated=${p.updated}`);
+    }
+  } catch (err) {
+    error = err;
+    ctx.logger.error("[dync] firstLoad:batch:error", err);
+  }
+  await ctx.state.setState((syncState) => ({
+    ...syncState,
+    firstLoadDone: true,
+    error
+  }));
+  ctx.logger.debug("[dync] Batch first load completed");
+}
+
+// src/index.shared.ts
+var DEFAULT_SYNC_INTERVAL_MILLIS = 2e3;
+var DEFAULT_LOGGER = console;
+var DEFAULT_MIN_LOG_LEVEL = "debug";
+var DEFAULT_MISSING_REMOTE_RECORD_STRATEGY = "insert-remote-record";
+var DEFAULT_CONFLICT_RESOLUTION_STRATEGY = "try-shallow-merge";
+var DyncBase = class {
+  adapter;
+  tableCache = /* @__PURE__ */ new Map();
+  mutationWrappedTables = /* @__PURE__ */ new Set();
+  syncEnhancedTables = /* @__PURE__ */ new Set();
+  mutationListeners = /* @__PURE__ */ new Set();
+  visibilitySubscription;
+  openPromise;
+  disableSyncPromise;
+  disableSyncPromiseResolver;
+  sleepAbortController;
+  closing = false;
+  // Per-table sync mode
+  syncApis = {};
+  // Batch sync mode
+  batchSync;
+  syncedTables = /* @__PURE__ */ new Set();
+  syncOptions;
+  logger;
+  syncTimerStarted = false;
+  mutationsDuringSync = false;
+  state;
+  name;
+  constructor(databaseName, syncApisOrBatchSync, storageAdapter, options) {
+    const isBatchMode = typeof syncApisOrBatchSync.push === "function";
+    if (isBatchMode) {
+      this.batchSync = syncApisOrBatchSync;
+      this.syncedTables = new Set(this.batchSync.syncTables);
+    } else {
+      this.syncApis = syncApisOrBatchSync;
+      this.syncedTables = new Set(Object.keys(this.syncApis));
+    }
+    this.adapter = storageAdapter;
+    this.name = databaseName;
+    this.syncOptions = {
+      syncInterval: DEFAULT_SYNC_INTERVAL_MILLIS,
+      logger: DEFAULT_LOGGER,
+      minLogLevel: DEFAULT_MIN_LOG_LEVEL,
+      missingRemoteRecordDuringUpdateStrategy: DEFAULT_MISSING_REMOTE_RECORD_STRATEGY,
+      conflictResolutionStrategy: DEFAULT_CONFLICT_RESOLUTION_STRATEGY,
+      ...options ?? {}
+    };
+    this.logger = newLogger(this.syncOptions.logger, this.syncOptions.minLogLevel);
+    this.state = new StateManager({
+      storageAdapter: this.adapter
+    });
+    const driverInfo = "driverType" in this.adapter ? ` (Driver: ${this.adapter.driverType})` : "";
+    this.logger.debug(`[dync] Initialized with ${this.adapter.type}${driverInfo}`);
+  }
+  version(versionNumber) {
+    const self = this;
+    const schemaOptions = {};
+    let storesDefined = false;
+    const builder = {
+      stores(schema) {
+        const usesStructuredSchema = Object.values(schema).some((def) => typeof def !== "string");
+        const stateTableSchema = usesStructuredSchema ? {
+          columns: {
+            [LOCAL_PK]: { type: "TEXT" },
+            value: { type: "TEXT" }
+          }
+        } : LOCAL_PK;
+        const fullSchema = {
+          ...schema,
+          [DYNC_STATE_TABLE]: stateTableSchema
+        };
+        for (const [tableName, tableSchema] of Object.entries(schema)) {
+          const isSyncTable = self.syncedTables.has(tableName);
+          if (typeof tableSchema === "string") {
+            if (isSyncTable) {
+              fullSchema[tableName] = `${LOCAL_PK}, &${SERVER_PK}, ${tableSchema}, ${UPDATED_AT}`;
+            }
+            self.logger.debug(
+              `[dync] Defining ${isSyncTable ? "" : "non-"}sync table '${tableName}' with primary key & indexes '${fullSchema[tableName]}'`
+            );
+          } else {
+            if (isSyncTable) {
+              fullSchema[tableName] = self.injectSyncColumns(tableSchema);
+            }
+            const schemaColumns = Object.keys(fullSchema[tableName].columns ?? {}).join(", ");
+            const schemaIndexes = (fullSchema[tableName].indexes ?? []).map((idx) => idx.columns.join("+")).join(", ");
+            self.logger.debug(
+              `[dync] Defining ${isSyncTable ? "" : "non-"}sync table '${tableName}' with columns ${schemaColumns} and indexes ${schemaIndexes}`
+            );
+          }
+        }
+        storesDefined = true;
+        self.adapter.defineSchema(versionNumber, fullSchema, schemaOptions);
+        self.setupEnhancedTables(Object.keys(schema));
+        return builder;
+      },
+      sqlite(configure) {
+        if (!storesDefined) {
+          throw new Error("Call stores() before registering sqlite migrations");
+        }
+        const sqliteOptions = schemaOptions.sqlite ??= {};
+        const migrations = sqliteOptions.migrations ??= {};
+        const configurator = {
+          upgrade(handler) {
+            migrations.upgrade = handler;
+          },
+          downgrade(handler) {
+            migrations.downgrade = handler;
+          }
+        };
+        configure(configurator);
+        return builder;
+      }
+    };
+    return builder;
+  }
+  async open() {
+    if (this.closing) {
+      return;
+    }
+    if (this.openPromise) {
+      return this.openPromise;
+    }
+    this.openPromise = (async () => {
+      if (this.closing) return;
+      await this.adapter.open();
+      if (this.closing) return;
+      await this.state.hydrate();
+    })();
+    return this.openPromise;
+  }
+  async close() {
+    this.closing = true;
+    if (this.openPromise) {
+      await this.openPromise.catch(() => {
+      });
+      this.openPromise = void 0;
+    }
+    await this.enableSync(false);
+    await this.adapter.close();
+    this.tableCache.clear();
+    this.mutationWrappedTables.clear();
+    this.syncEnhancedTables.clear();
+  }
+  async delete() {
+    await this.adapter.delete();
+    this.tableCache.clear();
+    this.mutationWrappedTables.clear();
+    this.syncEnhancedTables.clear();
+  }
+  async query(callback) {
+    return this.adapter.query(callback);
+  }
+  table(name) {
+    if (this.tableCache.has(name)) {
+      return this.tableCache.get(name);
+    }
+    const table = this.adapter.table(name);
+    const isSyncTable = this.syncedTables.has(name);
+    if (isSyncTable && !this.syncEnhancedTables.has(name)) {
+      this.enhanceSyncTable(table, name);
+    } else if (!isSyncTable && !this.mutationWrappedTables.has(name) && name !== DYNC_STATE_TABLE) {
+      wrapWithMutationEmitter(table, name, this.emitMutation.bind(this));
+      this.mutationWrappedTables.add(name);
+    }
+    this.tableCache.set(name, table);
+    return table;
+  }
+  async withTransaction(mode, tableNames, fn) {
+    await this.open();
+    return this.adapter.transaction(mode, tableNames, async () => {
+      const tables = {};
+      for (const tableName of tableNames) {
+        tables[tableName] = this.table(tableName);
+      }
+      return fn(tables);
+    });
+  }
+  setupEnhancedTables(tableNames) {
+    setupEnhancedTables(
+      {
+        owner: this,
+        tableCache: this.tableCache,
+        enhancedTables: this.syncEnhancedTables,
+        getTable: (name) => this.table(name)
+      },
+      tableNames
+    );
+    for (const tableName of tableNames) {
+      this.mutationWrappedTables.delete(tableName);
+    }
+  }
+  injectSyncColumns(schema) {
+    const columns = schema.columns ?? {};
+    if (columns[LOCAL_PK]) {
+      throw new Error(`Column '${LOCAL_PK}' is auto-injected for sync tables and cannot be defined manually.`);
+    }
+    if (columns[SERVER_PK]) {
+      throw new Error(`Column '${SERVER_PK}' is auto-injected for sync tables and cannot be defined manually.`);
+    }
+    if (columns[UPDATED_AT]) {
+      throw new Error(`Column '${UPDATED_AT}' is auto-injected for sync tables and cannot be defined manually.`);
+    }
+    const injectedColumns = {
+      ...columns,
+      [LOCAL_PK]: { type: "TEXT" },
+      [SERVER_PK]: { type: "INTEGER", unique: true },
+      [UPDATED_AT]: { type: "TEXT" }
+    };
+    const userIndexes = schema.indexes ?? [];
+    const hasUpdatedAtIndex = userIndexes.some((idx) => idx.columns.length === 1 && idx.columns[0] === UPDATED_AT);
+    const injectedIndexes = hasUpdatedAtIndex ? userIndexes : [...userIndexes, { columns: [UPDATED_AT] }];
+    return {
+      ...schema,
+      columns: injectedColumns,
+      indexes: injectedIndexes
+    };
+  }
+  enhanceSyncTable(table, tableName) {
+    enhanceSyncTable({
+      table,
+      tableName,
+      withTransaction: this.withTransaction.bind(this),
+      state: this.state,
+      enhancedTables: this.syncEnhancedTables,
+      emitMutation: this.emitMutation.bind(this)
+    });
+  }
+  async syncOnce() {
+    if (this.closing) {
+      return;
+    }
+    if (this.syncStatus === "syncing") {
+      this.mutationsDuringSync = true;
+      return;
+    }
+    this.syncStatus = "syncing";
+    this.mutationsDuringSync = false;
+    const pullResult = await this.pullAll();
+    const firstPushSyncError = await this.pushAll();
+    for (const tableName of pullResult.changedTables) {
+      this.emitMutation({ type: "pull", tableName });
+    }
+    this.syncStatus = "idle";
+    await this.state.setState((syncState) => ({
+      ...syncState,
+      error: pullResult.error ?? firstPushSyncError
+    }));
+    if (this.mutationsDuringSync) {
+      this.mutationsDuringSync = false;
+      this.syncOnce().catch(() => {
+      });
+    }
+  }
+  async pullAll() {
+    const baseContext = {
+      logger: this.logger,
+      state: this.state,
+      table: this.table.bind(this),
+      withTransaction: this.withTransaction.bind(this),
+      conflictResolutionStrategy: this.syncOptions.conflictResolutionStrategy
+    };
+    if (this.batchSync) {
+      return pullAllBatch({
+        ...baseContext,
+        batchSync: this.batchSync
+      });
+    }
+    return pullAll({
+      ...baseContext,
+      syncApis: this.syncApis
+    });
+  }
+  async pushAll() {
+    const baseContext = {
+      logger: this.logger,
+      state: this.state,
+      table: this.table.bind(this),
+      withTransaction: this.withTransaction.bind(this),
+      syncOptions: this.syncOptions
+    };
+    if (this.batchSync) {
+      return pushAllBatch({
+        ...baseContext,
+        batchSync: this.batchSync
+      });
+    }
+    return pushAll({
+      ...baseContext,
+      syncApis: this.syncApis
+    });
+  }
+  startSyncTimer(start) {
+    if (start) {
+      void this.tryStart();
+    } else {
+      this.syncTimerStarted = false;
+    }
+  }
+  async tryStart() {
+    if (this.syncTimerStarted) return;
+    this.syncTimerStarted = true;
+    while (this.syncTimerStarted) {
+      this.sleepAbortController = new AbortController();
+      await this.syncOnce();
+      await sleep(this.syncOptions.syncInterval, this.sleepAbortController.signal);
+    }
+    this.syncStatus = "disabled";
+    this.disableSyncPromiseResolver?.();
+  }
+  setupVisibilityListener(add) {
+    this.visibilitySubscription = addVisibilityChangeListener(add, this.visibilitySubscription, (isVisible) => this.handleVisibilityChange(isVisible));
+  }
+  handleVisibilityChange(isVisible) {
+    if (isVisible) {
+      this.logger.debug("[dync] sync:start-in-foreground");
+      this.startSyncTimer(true);
+    } else {
+      this.logger.debug("[dync] sync:pause-in-background");
+      this.startSyncTimer(false);
+    }
+  }
+  async startFirstLoad(onProgress) {
+    await this.open();
+    const baseContext = {
+      logger: this.logger,
+      state: this.state,
+      table: this.table.bind(this),
+      withTransaction: this.withTransaction.bind(this),
+      onProgress
+    };
+    if (this.batchSync) {
+      await startFirstLoadBatch({
+        ...baseContext,
+        batchSync: this.batchSync
+      });
+    } else {
+      await startFirstLoad({
+        ...baseContext,
+        syncApis: this.syncApis
+      });
+    }
+    for (const tableName of this.syncedTables) {
+      this.emitMutation({ type: "pull", tableName });
+    }
+  }
+  getSyncState() {
+    return this.state.getSyncState();
+  }
+  async resolveConflict(localId, keepLocal) {
+    const conflict = this.state.getState().conflicts?.[localId];
+    if (!conflict) {
+      this.logger.warn(`[dync] No conflict found for localId: ${localId}`);
+      return;
+    }
+    await this.withTransaction("rw", [conflict.stateKey, DYNC_STATE_TABLE], async (tables) => {
+      const txTable = tables[conflict.stateKey];
+      if (!keepLocal) {
+        const item = await txTable.get(localId);
+        if (item) {
+          for (const field of conflict.fields) {
+            item[field.key] = field.remoteValue;
+          }
+          await txTable.raw.update(localId, item);
+        } else {
+          this.logger.warn(`[dync] No local item found for localId: ${localId} to apply remote values`);
+        }
+        await this.state.setState((syncState) => ({
+          ...syncState,
+          pendingChanges: syncState.pendingChanges.filter((p) => !(p.localId === localId && p.stateKey === conflict.stateKey))
+        }));
+      }
+      await this.state.setState((syncState) => {
+        const ss = { ...syncState };
+        delete ss.conflicts?.[localId];
+        return ss;
+      });
+    });
+  }
+  async enableSync(enabled) {
+    if (!enabled) {
+      if (this.syncTimerStarted) {
+        this.disableSyncPromise = new Promise((resolve) => {
+          this.disableSyncPromiseResolver = resolve;
+        });
+        this.sleepAbortController?.abort();
+        this.syncStatus = "disabling";
+        this.startSyncTimer(false);
+        this.setupVisibilityListener(false);
+        return this.disableSyncPromise;
+      }
+      this.syncStatus = "disabled";
+      this.setupVisibilityListener(false);
+      return Promise.resolve();
+    }
+    this.syncStatus = "idle";
+    this.startSyncTimer(true);
+    this.setupVisibilityListener(true);
+    return Promise.resolve();
+  }
+  get syncStatus() {
+    return this.state.getSyncStatus();
+  }
+  set syncStatus(status) {
+    this.state.setSyncStatus(status);
+  }
+  onSyncStateChange(fn) {
+    return this.state.subscribe(fn);
+  }
+  onMutation(fn) {
+    this.mutationListeners.add(fn);
+    return () => this.mutationListeners.delete(fn);
+  }
+  emitMutation(event) {
+    if (event.type === "add" || event.type === "update" || event.type === "delete") {
+      if (this.syncTimerStarted) {
+        this.syncOnce().catch(() => {
+        });
+      }
+    }
+    for (const listener of this.mutationListeners) {
+      listener(event);
+    }
+  }
+  // Public API
+  sync = {
+    enable: this.enableSync.bind(this),
+    startFirstLoad: this.startFirstLoad.bind(this),
+    getState: this.getSyncState.bind(this),
+    resolveConflict: this.resolveConflict.bind(this),
+    onStateChange: this.onSyncStateChange.bind(this),
+    onMutation: this.onMutation.bind(this)
+  };
+};
+var DyncConstructor = DyncBase;
+var Dync = DyncConstructor;
+
+// src/react/useDync.ts
+function makeDync(config) {
+  const db = "syncApis" in config ? new Dync(config.databaseName, config.syncApis, config.storageAdapter, config.options) : new Dync(config.databaseName, config.batchSync, config.storageAdapter, config.options);
+  let cachedState = db.sync.getState();
+  const subscribe = (listener) => db.sync.onStateChange((nextState) => {
+    cachedState = nextState;
+    listener();
+  });
+  const getSnapshot = () => {
+    const fresh = db.sync.getState();
+    if (JSON.stringify(fresh) !== JSON.stringify(cachedState)) {
+      cachedState = fresh;
+    }
+    return cachedState;
+  };
+  const useDync = () => {
+    const syncState = (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+    return { db, syncState };
+  };
+  const boundUseLiveQuery = (querier, deps = [], tables) => {
+    return useLiveQueryImpl(db, querier, deps, tables);
+  };
+  return {
+    db,
+    useDync,
+    useLiveQuery: boundUseLiveQuery
+  };
+}
+function useLiveQueryImpl(db, querier, deps = [], tables) {
+  const [result, setResult] = (0, import_react.useState)(void 0);
+  const [, setError] = (0, import_react.useState)(null);
+  const isMountedRef = (0, import_react.useRef)(true);
+  const queryVersionRef = (0, import_react.useRef)(0);
+  const querierRef = (0, import_react.useRef)(querier);
+  const tablesRef = (0, import_react.useRef)(tables);
+  querierRef.current = querier;
+  tablesRef.current = tables;
+  const runQuery = (0, import_react.useCallback)(async () => {
+    const currentVersion = ++queryVersionRef.current;
+    try {
+      const queryResult = await querierRef.current(db);
+      if (isMountedRef.current && currentVersion === queryVersionRef.current) {
+        setResult(queryResult);
+        setError(null);
+      }
+    } catch (err) {
+      if (isMountedRef.current && currentVersion === queryVersionRef.current) {
+        setError(err);
+      }
+    }
+  }, [db]);
+  (0, import_react.useEffect)(() => {
+    runQuery();
+  }, [...deps, runQuery]);
+  (0, import_react.useEffect)(() => {
+    isMountedRef.current = true;
+    const unsubscribe = db.sync.onMutation((event) => {
+      if (!tablesRef.current || tablesRef.current.includes(event.tableName)) {
+        runQuery();
+      }
+    });
+    return () => {
+      isMountedRef.current = false;
+      unsubscribe();
+    };
+  }, [db, runQuery]);
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeDync
+});
+//# sourceMappingURL=index.cjs.map