@anfenn/dync 1.0.25 → 1.0.26

package/dist/react/index.cjs

@@ -20,1741 +20,47 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/react/index.ts
 var react_exports = {};
 __export(react_exports, {
-  makeDync: () => makeDync
+  useLiveQuery: () => useLiveQuery,
+  useSyncState: () => useSyncState
 });
 module.exports = __toCommonJS(react_exports);
 
-// src/react/useDync.ts
+// src/react/useSyncState.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";
-var ApiError = class extends Error {
-  isNetworkError;
-  cause;
-  constructor(message, isNetworkError2, cause) {
-    super(message);
-    this.name = "ApiError";
-    this.isNetworkError = isNetworkError2;
-    this.cause = cause;
-  }
-};
-
-// 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 parseApiError(error) {
-  if (error instanceof ApiError) {
-    return error;
-  }
-  if (typeof error === "string") {
-    return new ApiError(error, false);
-  }
-  return new ApiError(error.message, isNetworkError(error), error);
-}
-function isNetworkError(error) {
-  const message = error.message?.toLowerCase() ?? "";
-  const name = error.name;
-  if (message.includes("failed to fetch") || message.includes("network request failed")) {
-    return true;
-  }
-  const code = error.code;
-  if (code === "ERR_NETWORK" || code === "ECONNABORTED" || code === "ENOTFOUND" || code === "ECONNREFUSED") {
-    return true;
-  }
-  if (error.isAxiosError && error.response === void 0) {
-    return true;
-  }
-  if (name === "ApolloError" && error.networkError) {
-    return true;
-  }
-  if (message.includes("network error") || message.includes("networkerror")) {
-    return true;
-  }
-  return false;
-}
-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;
-  apiError;
-  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();
-  }
-  setApiError(error) {
-    this.apiError = error ? parseApiError(error) : void 0;
-    this.emit();
-  }
-  addPendingChange(change) {
-    const next = clonePersistedState(this.persistedState);
-    const queueItem = next.pendingChanges.find((p) => p.localId === change.localId && p.tableName === change.tableName);
-    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,
-        tableName: change.tableName,
-        localId: change.localId,
-        id: change.id,
-        version: 1,
-        changes: omittedChanges,
-        before: omittedBefore,
-        after: omittedAfter
-      });
-    }
-    this.persistedState = next;
-    return this.persist();
-  }
-  samePendingVersion(tableName, localId, version) {
-    return this.persistedState.pendingChanges.find((p) => p.localId === localId && p.tableName === tableName)?.version === version;
-  }
-  removePendingChange(localId, tableName) {
-    const next = clonePersistedState(this.persistedState);
-    next.pendingChanges = next.pendingChanges.filter((p) => !(p.localId === localId && p.tableName === tableName));
-    this.persistedState = next;
-    return this.persist();
-  }
-  updatePendingChange(tableName, localId, action, id) {
-    const next = clonePersistedState(this.persistedState);
-    const changeItem = next.pendingChanges.find((p) => p.tableName === tableName && p.localId === localId);
-    if (changeItem) {
-      changeItem.action = action;
-      if (id) changeItem.id = id;
-      this.persistedState = next;
-      return this.persist();
-    }
-    return Promise.resolve();
-  }
-  setPendingChangeBefore(tableName, localId, before) {
-    const next = clonePersistedState(this.persistedState);
-    const changeItem = next.pendingChanges.find((p) => p.tableName === tableName && 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, this.apiError);
-  }
-  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, apiError) {
-  const persisted = clonePersistedState(state);
-  const syncState = {
-    ...persisted,
-    status,
-    hydrated,
-    apiError
-  };
-  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] = {
-      tableName: value.tableName,
-      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 */,
-        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 */,
-        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 */,
-          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 */,
-          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 */,
-          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 */,
-          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 */,
-            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 */,
-            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 */,
-            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 [tableName, api] of Object.entries(ctx.syncApis)) {
-    try {
-      const lastPulled = ctx.state.getState().lastPulled[tableName];
-      const since = lastPulled ? new Date(lastPulled) : /* @__PURE__ */ new Date(0);
-      ctx.logger.debug(`[dync] pull:start tableName=${tableName} since=${since.toISOString()}`);
-      const serverData = await api.list(since);
-      const changed = await processPullData(tableName, serverData, since, ctx);
-      if (changed) changedTables.push(tableName);
-    } catch (err) {
-      firstSyncError = firstSyncError ?? err;
-      ctx.logger.error(`[dync] pull:error tableName=${tableName}`, err);
-    }
-  }
-  return { error: firstSyncError, changedTables };
-}
-async function handleRemoteItemUpdate(table, tableName, localItem, remote, ctx) {
-  const pendingChange = ctx.state.getState().pendingChanges.find((p) => p.tableName === tableName && p.localId === localItem._localId);
-  const conflictStrategy = ctx.conflictResolutionStrategy;
-  if (pendingChange) {
-    ctx.logger.debug(`[dync] pull:conflict-strategy:${conflictStrategy} tableName=${tableName} 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, tableName);
-        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]: { tableName, 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 tableName=${tableName} 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 [tableName, serverData] of Object.entries(serverDataByTable)) {
-      if (!ctx.batchSync.syncTables.includes(tableName)) {
-        ctx.logger.warn(`[dync] pull:batch:unknown-table tableName=${tableName}`);
-        continue;
-      }
-      try {
-        const changed = await processPullData(tableName, serverData, sinceMap[tableName], ctx);
-        if (changed) changedTables.push(tableName);
-      } catch (err) {
-        firstSyncError = firstSyncError ?? err;
-        ctx.logger.error(`[dync] pull:batch:error tableName=${tableName}`, err);
-      }
-    }
-  } catch (err) {
-    firstSyncError = err;
-    ctx.logger.error(`[dync] pull:batch:error`, err);
-  }
-  return { error: firstSyncError, changedTables };
-}
-async function processPullData(tableName, serverData, since, ctx) {
-  if (!serverData?.length) return false;
-  ctx.logger.debug(`[dync] pull:process tableName=${tableName} count=${serverData.length}`);
-  let newest = since;
-  let hasChanges = false;
-  await ctx.withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
-    const txTable = tables[tableName];
-    const pendingRemovalById = new Set(
-      ctx.state.getState().pendingChanges.filter((p) => p.tableName === tableName && 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 tableName=${tableName} 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 tableName=${tableName} id=${remote.id}`);
-          hasChanges = true;
-        }
-        continue;
-      }
-      delete remote.deleted;
-      if (localItem) {
-        await handleRemoteItemUpdate(txTable, tableName, localItem, remote, ctx);
-        hasChanges = true;
-      } else {
-        const newLocalItem = { ...remote, _localId: createLocalId() };
-        await txTable.raw.add(newLocalItem);
-        ctx.logger.debug(`[dync] pull:add tableName=${tableName} id=${remote.id}`);
-        hasChanges = true;
-      }
-    }
-    await ctx.state.setState((syncState) => ({
-      ...syncState,
-      lastPulled: {
-        ...syncState.lastPulled,
-        [tableName]: newest.toISOString()
-      }
-    }));
-  });
-  return hasChanges;
-}
-
-// src/core/pushOperations.ts
-async function handleRemoveSuccess(change, ctx) {
-  const { tableName, localId, id } = change;
-  ctx.logger.debug(`[dync] push:remove:success tableName=${tableName} localId=${localId} id=${id}`);
-  await ctx.state.removePendingChange(localId, tableName);
-}
-async function handleUpdateSuccess(change, ctx) {
-  const { tableName, localId, version, changes } = change;
-  ctx.logger.debug(`[dync] push:update:success tableName=${tableName} localId=${localId} id=${change.id}`);
-  if (ctx.state.samePendingVersion(tableName, localId, version)) {
-    await ctx.state.removePendingChange(localId, tableName);
-  } else {
-    await ctx.state.setPendingChangeBefore(tableName, localId, changes);
-  }
-}
-async function handleCreateSuccess(change, serverResult, ctx) {
-  const { tableName, localId, version, changes, id } = change;
-  ctx.logger.debug(`[dync] push:create:success tableName=${tableName} localId=${localId} id=${id ?? serverResult.id}`);
-  await ctx.withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
-    const txTable = tables[tableName];
-    const wasChanged = await txTable.raw.update(localId, serverResult) ?? 0;
-    if (wasChanged && ctx.state.samePendingVersion(tableName, localId, version)) {
-      await ctx.state.removePendingChange(localId, tableName);
-    } else {
-      const nextAction = wasChanged ? "update" /* Update */ : "remove" /* Remove */;
-      await ctx.state.updatePendingChange(tableName, localId, nextAction, serverResult.id);
-      if (nextAction === "remove" /* Remove */) return;
-    }
-  });
-  const finalItem = { ...changes, ...serverResult, _localId: localId };
-  ctx.syncOptions.onAfterRemoteAdd?.(tableName, 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.tableName];
-  if (!api) return;
-  ctx.logger.debug(`[dync] push:attempt action=${change.action} tableName=${change.tableName} localId=${change.localId}`);
-  const { action, tableName, localId, id, changes, after } = change;
-  switch (action) {
-    case "remove" /* Remove */:
-      if (!id) {
-        ctx.logger.warn(`[dync] push:remove:no-id tableName=${tableName} localId=${localId}`);
-        await ctx.state.removePendingChange(localId, tableName);
-        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 tableName=${tableName} 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 tableName=${tableName} localId=${localId} id=${id}`);
-        if (ctx.state.samePendingVersion(tableName, localId, change.version)) {
-          await ctx.state.removePendingChange(localId, tableName);
-        }
-      }
-      break;
-    }
-  }
-}
-async function handleMissingRemoteRecord(change, ctx) {
-  const { tableName, localId } = change;
-  const strategy = ctx.syncOptions.missingRemoteRecordDuringUpdateStrategy;
-  let localItem;
-  await ctx.withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
-    const txTable = tables[tableName];
-    localItem = await txTable.get(localId);
-    if (!localItem) {
-      ctx.logger.warn(`[dync] push:missing-remote:no-local-item tableName=${tableName} localId=${localId}`);
-      await ctx.state.removePendingChange(localId, tableName);
-      return;
-    }
-    switch (strategy) {
-      case "delete-local-record":
-        await txTable.raw.delete(localId);
-        ctx.logger.debug(`[dync] push:missing-remote:${strategy} tableName=${tableName} 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 */,
-          tableName,
-          localId: newItem._localId,
-          changes: newItem,
-          before: null
-        });
-        ctx.logger.debug(`[dync] push:missing-remote:${strategy} tableName=${tableName} id=${newItem.id}`);
-        break;
-      }
-      case "ignore":
-        ctx.logger.debug(`[dync] push:missing-remote:${strategy} tableName=${tableName} id=${localItem.id}`);
-        break;
-      default:
-        ctx.logger.error(`[dync] push:missing-remote:unknown-strategy tableName=${tableName} id=${localItem.id} strategy=${strategy}`);
-        break;
-    }
-    await ctx.state.removePendingChange(localId, tableName);
-  });
-  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.tableName)).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 tableName=${change.tableName} 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.tableName,
-      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, tableName, localId } = change;
-  if (!result.success) {
-    if (action === "update" /* Update */) {
-      await handleMissingRemoteRecord(change, ctx);
-    } else {
-      ctx.logger.warn(`[dync] push:batch:failed tableName=${tableName} 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 [tableName, api] of Object.entries(ctx.syncApis)) {
-    if (!api.firstLoad) {
-      ctx.logger.error(`[dync] firstLoad:no-api-function tableName=${tableName}`);
-      continue;
-    }
-    try {
-      ctx.logger.info(`[dync] firstLoad:start tableName=${tableName}`);
-      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, tableName, batch, isEmptyTable, lastId === void 0);
-        totalInserted += inserted;
-        totalUpdated += updated;
-        if (ctx.onProgress) {
-          ctx.onProgress({
-            table: tableName,
-            inserted: totalInserted,
-            updated: totalUpdated,
-            total: totalInserted + totalUpdated
-          });
-        }
-        if (lastId === void 0) {
-          isEmptyTable = await ctx.table(tableName).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 tableName=${tableName} inserted=${totalInserted} updated=${totalUpdated}`);
-    } catch (err) {
-      error = error ?? err;
-      ctx.logger.error(`[dync] firstLoad:error tableName=${tableName}`, err);
-    }
-  }
-  await ctx.state.setState((syncState) => ({
-    ...syncState,
-    firstLoadDone: true,
-    error
-  }));
-  ctx.logger.debug("[dync] First load completed");
-}
-async function processBatchInChunks(ctx, tableName, batch, isEmptyTable, isFirstBatch) {
-  let newest = new Date(ctx.state.getState().lastPulled[tableName] || 0);
-  return ctx.withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
-    const txTable = tables[tableName];
-    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,
-        [tableName]: 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 [tableName, batch] of Object.entries(result.data)) {
-        if (!ctx.batchSync.syncTables.includes(tableName)) {
-          ctx.logger.warn(`[dync] firstLoad:batch:unknown-table tableName=${tableName}`);
-          continue;
-        }
-        if (!batch?.length) continue;
-        const isFirstBatch = progress[tableName].inserted === 0 && progress[tableName].updated === 0;
-        const isEmptyTable = isFirstBatch && await ctx.table(tableName).count() === 0;
-        const { inserted, updated } = await processBatchInChunks(ctx, tableName, batch, isEmptyTable, isFirstBatch);
-        progress[tableName].inserted += inserted;
-        progress[tableName].updated += updated;
-        if (ctx.onProgress) {
-          ctx.onProgress({
-            table: tableName,
-            inserted: progress[tableName].inserted,
-            updated: progress[tableName].updated,
-            total: progress[tableName].inserted + progress[tableName].updated
-          });
-        }
-      }
-      cursors = result.cursors;
-      if (batchCount % 5 === 0) {
-        await yieldToEventLoop();
-      }
-      if (!result.hasMore) {
-        break;
-      }
-    }
-    for (const [tableName, p] of Object.entries(progress)) {
-      ctx.logger.info(`[dync] firstLoad:batch:done tableName=${tableName} 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");
+function useSyncState(db) {
+  const cacheRef = (0, import_react.useRef)(db.sync.state);
+  const subscribe = (0, import_react.useCallback)(
+    (listener) => db.sync.onStateChange((nextState) => {
+      cacheRef.current = nextState;
+      listener();
+    }),
+    [db]
+  );
+  const getSnapshot = (0, import_react.useCallback)(() => {
+    const fresh = db.sync.state;
+    if (JSON.stringify(fresh) !== JSON.stringify(cacheRef.current)) {
+      cacheRef.current = fresh;
+    }
+    return cacheRef.current;
+  }, [db]);
+  return (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
 }
 
-// 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";
-    this.state.setApiError(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.tableName, DYNC_STATE_TABLE], async (tables) => {
-      const txTable = tables[conflict.tableName];
-      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.tableName === conflict.tableName))
-        }));
-      }
-      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);
+// src/react/useLiveQuery.ts
+var import_react2 = require("react");
+function useLiveQuery(db, querier, deps = [], tables) {
+  const [result, setResult] = (0, import_react2.useState)(void 0);
+  const [, setError] = (0, import_react2.useState)(null);
+  const isMountedRef = (0, import_react2.useRef)(true);
+  const queryVersionRef = (0, import_react2.useRef)(0);
+  const querierRef = (0, import_react2.useRef)(querier);
+  const tablesRef = (0, import_react2.useRef)(tables);
   querierRef.current = querier;
   tablesRef.current = tables;
-  const runQuery = (0, import_react.useCallback)(async () => {
+  const runQuery = (0, import_react2.useCallback)(async () => {
     const currentVersion = ++queryVersionRef.current;
     try {
-      const queryResult = await querierRef.current(db);
+      const queryResult = await querierRef.current();
       if (isMountedRef.current && currentVersion === queryVersionRef.current) {
         setResult(queryResult);
         setError(null);
@@ -1764,11 +70,11 @@ function useLiveQueryImpl(db, querier, deps = [], tables) {
         setError(err);
       }
     }
-  }, [db]);
-  (0, import_react.useEffect)(() => {
+  }, []);
+  (0, import_react2.useEffect)(() => {
     runQuery();
   }, [...deps, runQuery]);
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     isMountedRef.current = true;
     const unsubscribe = db.sync.onMutation((event) => {
       if (!tablesRef.current || tablesRef.current.includes(event.tableName)) {
@@ -1784,6 +90,7 @@ function useLiveQueryImpl(db, querier, deps = [], tables) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  makeDync
+  useLiveQuery,
+  useSyncState
 });
 //# sourceMappingURL=index.cjs.map