@anfenn/dync 1.0.0

package/dist/chunk-LGHOZECP.js

@@ -0,0 +1,3884 @@
+// 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 SyncAction = /* @__PURE__ */ ((SyncAction2) => {
+  SyncAction2["Create"] = "create";
+  SyncAction2["Update"] = "update";
+  SyncAction2["Remove"] = "remove";
+  return SyncAction2;
+})(SyncAction || {});
+
+// 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/storage/memory/MemoryQueryContext.ts
+var MemoryQueryContext = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  table(name) {
+    return this.adapter.table(name);
+  }
+  transaction(mode, tableNames, callback) {
+    return this.adapter.transaction(mode, tableNames, callback);
+  }
+};
+
+// src/storage/memory/types.ts
+var createDefaultState = () => ({
+  predicate: () => true,
+  orderBy: void 0,
+  reverse: false,
+  offset: 0,
+  limit: void 0,
+  distinct: false
+});
+
+// src/storage/memory/MemoryCollection.ts
+var MemoryCollection = class _MemoryCollection {
+  table;
+  state;
+  constructor(table, state) {
+    this.table = table;
+    this.state = state;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  matches(record, key) {
+    return this.state.predicate(record, key);
+  }
+  clone(_props) {
+    return new _MemoryCollection(this.table, { ...this.state });
+  }
+  reverse() {
+    return this.withState({ reverse: !this.state.reverse });
+  }
+  offset(offset) {
+    return this.withState({ offset });
+  }
+  limit(count) {
+    return this.withState({ limit: count });
+  }
+  toCollection() {
+    return this.clone();
+  }
+  distinct() {
+    return this.withState({ distinct: true });
+  }
+  jsFilter(predicate) {
+    return this.withState({ predicate: this.combinePredicate(predicate, "and") });
+  }
+  or(index) {
+    return this.table.createWhereClause(index, this);
+  }
+  async first() {
+    const entries = this.materializeEntries(true);
+    return entries.at(0)?.[1];
+  }
+  async last() {
+    const entries = this.materializeEntries(true);
+    return entries.at(-1)?.[1];
+  }
+  async each(callback) {
+    const entries = this.materializeEntries(true);
+    for (let index = 0; index < entries.length; index += 1) {
+      const [, record] = entries[index];
+      await callback(record, index);
+    }
+  }
+  async eachKey(callback) {
+    const keys = await this.keys();
+    for (let index = 0; index < keys.length; index += 1) {
+      await callback(keys[index], index);
+    }
+  }
+  async eachPrimaryKey(callback) {
+    const keys = await this.primaryKeys();
+    for (let index = 0; index < keys.length; index += 1) {
+      await callback(keys[index], index);
+    }
+  }
+  async eachUniqueKey(callback) {
+    const keys = await this.uniqueKeys();
+    for (let index = 0; index < keys.length; index += 1) {
+      await callback(keys[index], index);
+    }
+  }
+  async keys() {
+    return this.materializeEntries(false).map(([key, record]) => this.table.resolvePublicKey(record, key));
+  }
+  async primaryKeys() {
+    return this.keys();
+  }
+  async uniqueKeys() {
+    const seen = /* @__PURE__ */ new Set();
+    const keys = [];
+    for (const [key, record] of this.materializeEntries(false)) {
+      const publicKey = this.table.resolvePublicKey(record, key);
+      const signature = JSON.stringify(publicKey);
+      if (!seen.has(signature)) {
+        seen.add(signature);
+        keys.push(publicKey);
+      }
+    }
+    return keys;
+  }
+  async count() {
+    return this.materializeEntries(false).length;
+  }
+  async sortBy(key) {
+    const entries = this.materializeEntries(true);
+    entries.sort((a, b) => this.table.compareValues(a[1][key], b[1][key]));
+    return entries.map(([, record]) => record);
+  }
+  async delete() {
+    const entries = this.materializeEntries(false);
+    for (const [key] of entries) {
+      this.table.deleteByKey(key);
+    }
+    return entries.length;
+  }
+  async modify(changes) {
+    const entries = this.materializeEntries(false);
+    let modified = 0;
+    for (const [key] of entries) {
+      const current = this.table.getMutableRecord(key);
+      if (!current) {
+        continue;
+      }
+      if (typeof changes === "function") {
+        const clone = this.table.cloneRecord(current);
+        await changes(clone);
+        clone._localId = current._localId ?? key;
+        this.table.setMutableRecord(key, clone);
+      } else {
+        const updated = { ...current, ...changes, _localId: current._localId ?? key };
+        this.table.setMutableRecord(key, updated);
+      }
+      modified += 1;
+    }
+    return modified;
+  }
+  async toArray() {
+    return this.materializeEntries(true).map(([, record]) => record);
+  }
+  withState(overrides) {
+    return new _MemoryCollection(this.table, {
+      ...this.state,
+      ...overrides,
+      predicate: overrides.predicate ?? this.state.predicate
+    });
+  }
+  combinePredicate(predicate, mode) {
+    if (mode === "and") {
+      return (record, key) => this.state.predicate(record, key) && predicate(record);
+    }
+    return (record, key) => this.state.predicate(record, key) || predicate(record);
+  }
+  materializeEntries(clone) {
+    let entries = this.table.entries().filter(([key, record]) => this.state.predicate(record, key));
+    if (this.state.orderBy) {
+      const { index, direction } = this.state.orderBy;
+      entries = [...entries].sort((a, b) => this.table.compareEntries(a[1], b[1], index));
+      if (direction === "desc") {
+        entries.reverse();
+      }
+    }
+    if (this.state.reverse) {
+      entries = [...entries].reverse();
+    }
+    if (this.state.distinct) {
+      const seen = /* @__PURE__ */ new Set();
+      entries = entries.filter(([, record]) => {
+        const signature = JSON.stringify(record);
+        if (seen.has(signature)) {
+          return false;
+        }
+        seen.add(signature);
+        return true;
+      });
+    }
+    if (this.state.offset > 0) {
+      entries = entries.slice(this.state.offset);
+    }
+    if (typeof this.state.limit === "number") {
+      entries = entries.slice(0, this.state.limit);
+    }
+    if (clone) {
+      return entries.map(([key, record]) => [key, this.table.cloneRecord(record)]);
+    }
+    return entries;
+  }
+};
+
+// src/storage/memory/MemoryWhereClause.ts
+var MemoryWhereClause = class {
+  table;
+  index;
+  baseCollection;
+  constructor(table, index, baseCollection) {
+    this.table = table;
+    this.index = index;
+    this.baseCollection = baseCollection;
+  }
+  equals(value) {
+    return this.createCollection((current) => this.table.compareValues(current, value) === 0);
+  }
+  above(value) {
+    return this.createCollection((current) => this.table.compareValues(current, value) > 0);
+  }
+  aboveOrEqual(value) {
+    return this.createCollection((current) => this.table.compareValues(current, value) >= 0);
+  }
+  below(value) {
+    return this.createCollection((current) => this.table.compareValues(current, value) < 0);
+  }
+  belowOrEqual(value) {
+    return this.createCollection((current) => this.table.compareValues(current, value) <= 0);
+  }
+  between(lower, upper, includeLower = true, includeUpper = false) {
+    return this.createCollection((current) => {
+      const lowerCmp = this.table.compareValues(current, lower);
+      const upperCmp = this.table.compareValues(current, upper);
+      const lowerOk = includeLower ? lowerCmp >= 0 : lowerCmp > 0;
+      const upperOk = includeUpper ? upperCmp <= 0 : upperCmp < 0;
+      return lowerOk && upperOk;
+    });
+  }
+  inAnyRange(ranges, options) {
+    const includeLower = options?.includeLower ?? true;
+    const includeUpper = options?.includeUpper ?? false;
+    return this.createCollection((current) => {
+      for (const [lower, upper] of ranges) {
+        const lowerCmp = this.table.compareValues(current, lower);
+        const upperCmp = this.table.compareValues(current, upper);
+        const lowerOk = includeLower ? lowerCmp >= 0 : lowerCmp > 0;
+        const upperOk = includeUpper ? upperCmp <= 0 : upperCmp < 0;
+        if (lowerOk && upperOk) {
+          return true;
+        }
+      }
+      return false;
+    });
+  }
+  startsWith(prefix) {
+    return this.createCollection((current) => typeof current === "string" && current.startsWith(prefix));
+  }
+  startsWithIgnoreCase(prefix) {
+    return this.createCollection((current) => typeof current === "string" && current.toLowerCase().startsWith(prefix.toLowerCase()));
+  }
+  startsWithAnyOf(...args) {
+    const prefixes = this.flattenArgs(args);
+    return this.createCollection((current) => typeof current === "string" && prefixes.some((prefix) => current.startsWith(prefix)));
+  }
+  startsWithAnyOfIgnoreCase(...args) {
+    const prefixes = this.flattenArgs(args).map((prefix) => prefix.toLowerCase());
+    return this.createCollection((current) => typeof current === "string" && prefixes.some((prefix) => current.toLowerCase().startsWith(prefix)));
+  }
+  equalsIgnoreCase(value) {
+    return this.createCollection((current) => typeof current === "string" && current.toLowerCase() === value.toLowerCase());
+  }
+  anyOf(...args) {
+    const values = this.flattenArgs(args);
+    const valueSet = new Set(values.map((entry) => JSON.stringify(entry)));
+    return this.createCollection((current) => valueSet.has(JSON.stringify(current)));
+  }
+  anyOfIgnoreCase(...args) {
+    const values = this.flattenArgs(args).map((value) => value.toLowerCase());
+    const valueSet = new Set(values);
+    return this.createCollection((current) => typeof current === "string" && valueSet.has(current.toLowerCase()));
+  }
+  noneOf(...args) {
+    const values = this.flattenArgs(args);
+    const valueSet = new Set(values.map((entry) => JSON.stringify(entry)));
+    return this.createCollection((current) => !valueSet.has(JSON.stringify(current)));
+  }
+  notEqual(value) {
+    return this.createCollection((current) => this.table.compareValues(current, value) !== 0);
+  }
+  createCollection(predicate) {
+    const condition = (record, _key) => predicate(this.table.getIndexValue(record, this.index));
+    if (this.baseCollection) {
+      const combined = (record, key) => this.baseCollection.matches(record, key) || predicate(this.table.getIndexValue(record, this.index));
+      return this.table.createCollectionFromPredicate(combined, this.baseCollection);
+    }
+    return this.table.createCollectionFromPredicate(condition);
+  }
+  flattenArgs(args) {
+    if (args.length === 1 && Array.isArray(args[0])) {
+      return args[0];
+    }
+    return args;
+  }
+};
+
+// src/storage/memory/MemoryTable.ts
+var MemoryTable = class {
+  name;
+  schema = void 0;
+  primaryKey = LOCAL_PK;
+  hook = Object.freeze({});
+  raw;
+  records = /* @__PURE__ */ new Map();
+  constructor(name) {
+    this.name = name;
+    this.raw = {
+      add: async (item) => this.baseAdd(item),
+      put: async (item) => this.basePut(item),
+      update: async (key, changes) => this.baseUpdate(key, changes),
+      delete: async (key) => {
+        this.baseDelete(key);
+      },
+      get: async (key) => this.baseGet(key),
+      bulkAdd: async (items) => this.baseBulkAdd(items),
+      bulkPut: async (items) => this.baseBulkPut(items),
+      bulkUpdate: async (keysAndChanges) => this.baseBulkUpdate(keysAndChanges),
+      bulkDelete: async (keys) => this.baseBulkDelete(keys),
+      clear: async () => this.baseClear()
+    };
+  }
+  async add(item) {
+    return this.baseAdd(item);
+  }
+  async put(item) {
+    return this.basePut(item);
+  }
+  async update(key, changes) {
+    return this.baseUpdate(key, changes);
+  }
+  async delete(key) {
+    this.baseDelete(key);
+  }
+  async clear() {
+    this.baseClear();
+  }
+  baseClear() {
+    this.records.clear();
+  }
+  async get(key) {
+    const stored = this.baseGet(key);
+    return stored ? this.cloneRecord(stored) : void 0;
+  }
+  async toArray() {
+    return this.entries().map(([, record]) => this.cloneRecord(record));
+  }
+  async count() {
+    return this.records.size;
+  }
+  async bulkAdd(items) {
+    return this.baseBulkAdd(items);
+  }
+  baseBulkAdd(items) {
+    let lastKey = void 0;
+    for (let index = 0; index < items.length; index += 1) {
+      const item = items[index];
+      lastKey = this.baseAdd(item);
+    }
+    return lastKey;
+  }
+  async bulkPut(items) {
+    return this.baseBulkPut(items);
+  }
+  baseBulkPut(items) {
+    let lastKey = void 0;
+    for (let index = 0; index < items.length; index += 1) {
+      const item = items[index];
+      lastKey = this.basePut(item);
+    }
+    return lastKey;
+  }
+  async bulkGet(keys) {
+    return Promise.all(keys.map((key) => this.get(key)));
+  }
+  async bulkUpdate(keysAndChanges) {
+    return this.baseBulkUpdate(keysAndChanges);
+  }
+  baseBulkUpdate(keysAndChanges) {
+    let updatedCount = 0;
+    for (const { key, changes } of keysAndChanges) {
+      const result = this.baseUpdate(key, changes);
+      updatedCount += result;
+    }
+    return updatedCount;
+  }
+  async bulkDelete(keys) {
+    this.baseBulkDelete(keys);
+  }
+  baseBulkDelete(keys) {
+    for (const key of keys) {
+      this.baseDelete(key);
+    }
+  }
+  where(index) {
+    return this.createWhereClause(index);
+  }
+  orderBy(index) {
+    return this.createCollection({
+      orderBy: { index, direction: "asc" }
+    });
+  }
+  reverse() {
+    return this.createCollection({ reverse: true });
+  }
+  offset(offset) {
+    return this.createCollection({ offset });
+  }
+  limit(count) {
+    return this.createCollection({ limit: count });
+  }
+  mapToClass(_ctor) {
+    return this;
+  }
+  async each(callback) {
+    for (const [, record] of this.entries()) {
+      await callback(this.cloneRecord(record));
+    }
+  }
+  jsFilter(predicate) {
+    return this.createCollection({ predicate: (record) => predicate(record) });
+  }
+  createCollection(stateOverrides) {
+    const baseState = createDefaultState();
+    const state = {
+      ...baseState,
+      ...stateOverrides,
+      predicate: stateOverrides?.predicate ?? baseState.predicate
+    };
+    return new MemoryCollection(this, state);
+  }
+  createCollectionFromPredicate(predicate, template) {
+    const baseState = template ? template.getState() : createDefaultState();
+    return new MemoryCollection(this, {
+      ...baseState,
+      predicate
+    });
+  }
+  createWhereClause(index, baseCollection) {
+    return new MemoryWhereClause(this, index, baseCollection);
+  }
+  entries() {
+    return Array.from(this.records.entries());
+  }
+  cloneRecord(record) {
+    return { ...record };
+  }
+  deleteByKey(key) {
+    this.records.delete(key);
+  }
+  getMutableRecord(key) {
+    return this.records.get(key);
+  }
+  setMutableRecord(key, record) {
+    this.records.set(key, { ...record, _localId: record._localId ?? key });
+  }
+  resolvePublicKey(record, key) {
+    if (record._localId !== void 0) {
+      return record._localId;
+    }
+    if (record.id !== void 0) {
+      return record.id;
+    }
+    return key;
+  }
+  getIndexValue(record, index) {
+    if (Array.isArray(index)) {
+      return index.map((key) => record[key]);
+    }
+    return record[index];
+  }
+  compareEntries(left, right, index) {
+    if (Array.isArray(index)) {
+      for (const key of index) {
+        const diff = this.compareValues(left[key], right[key]);
+        if (diff !== 0) {
+          return diff;
+        }
+      }
+      return 0;
+    }
+    return this.compareValues(left[index], right[index]);
+  }
+  compareValues(left, right) {
+    const normalizedLeft = this.normalizeComparableValue(left);
+    const normalizedRight = this.normalizeComparableValue(right);
+    if (normalizedLeft < normalizedRight) {
+      return -1;
+    }
+    if (normalizedLeft > normalizedRight) {
+      return 1;
+    }
+    return 0;
+  }
+  normalizeComparableValue(value) {
+    if (Array.isArray(value)) {
+      return value.map((entry) => this.normalizeComparableValue(entry));
+    }
+    if (value instanceof Date) {
+      return value.valueOf();
+    }
+    return value ?? null;
+  }
+  baseAdd(item) {
+    const primaryKey = this.createPrimaryKey(item);
+    const stored = { ...item, _localId: primaryKey };
+    this.records.set(primaryKey, stored);
+    return primaryKey;
+  }
+  basePut(item) {
+    const primaryKey = this.createPrimaryKey(item);
+    const stored = { ...item, _localId: primaryKey };
+    this.records.set(primaryKey, stored);
+    return primaryKey;
+  }
+  baseUpdate(key, changes) {
+    const primaryKey = this.resolveKey(key);
+    if (!primaryKey) {
+      return 0;
+    }
+    const existing = this.records.get(primaryKey);
+    if (!existing) {
+      return 0;
+    }
+    const updated = { ...existing, ...changes, _localId: existing._localId ?? primaryKey };
+    this.records.set(primaryKey, updated);
+    return 1;
+  }
+  baseDelete(key) {
+    const primaryKey = this.resolveKey(key);
+    if (primaryKey) {
+      this.records.delete(primaryKey);
+    }
+  }
+  baseGet(key) {
+    const primaryKey = this.resolveKey(key);
+    if (!primaryKey) {
+      return void 0;
+    }
+    return this.records.get(primaryKey);
+  }
+  createPrimaryKey(item) {
+    if (item._localId && typeof item._localId === "string") {
+      return item._localId;
+    }
+    if (item.id !== void 0 && (typeof item.id === "string" || typeof item.id === "number" || typeof item.id === "bigint")) {
+      return String(item.id);
+    }
+    return createLocalId();
+  }
+  resolveKey(key) {
+    if (typeof key === "string") {
+      return key;
+    }
+    if (typeof key === "number" || typeof key === "bigint") {
+      return String(key);
+    }
+    if (key && typeof key === "object" && "id" in key) {
+      const lookup = key.id;
+      for (const [storedKey, record] of this.records.entries()) {
+        if (record.id === lookup) {
+          return storedKey;
+        }
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/storage/memory/MemoryAdapter.ts
+var MemoryAdapter = class {
+  type = "MemoryAdapter";
+  name;
+  tables = /* @__PURE__ */ new Map();
+  constructor(name) {
+    this.name = name;
+  }
+  async open() {
+  }
+  async close() {
+    this.tables.clear();
+  }
+  async delete() {
+    this.tables.clear();
+  }
+  async query(callback) {
+    return callback(new MemoryQueryContext(this));
+  }
+  defineSchema(_version, schema, _options) {
+    for (const tableName of Object.keys(schema)) {
+      this.ensureTable(tableName);
+    }
+  }
+  table(name) {
+    return this.ensureTable(name);
+  }
+  async transaction(_mode, tableNames, callback) {
+    const tables = {};
+    for (const tableName of tableNames) {
+      tables[tableName] = this.ensureTable(tableName);
+    }
+    return callback({ tables });
+  }
+  ensureTable(name) {
+    if (!this.tables.has(name)) {
+      this.tables.set(name, new MemoryTable(name));
+    }
+    return this.tables.get(name);
+  }
+};
+
+// src/storage/sqlite/helpers.ts
+var SQLITE_SCHEMA_VERSION_STATE_KEY = "sqlite_schema_version";
+var DEFAULT_STREAM_BATCH_SIZE = 200;
+var createDefaultState2 = () => ({
+  sqlConditions: [],
+  jsPredicate: void 0,
+  orderBy: void 0,
+  reverse: false,
+  offset: 0,
+  limit: void 0,
+  distinct: false
+});
+var buildWhereClause = (conditions) => {
+  if (conditions.length === 0) {
+    return { whereClause: "", parameters: [] };
+  }
+  const clauses = [];
+  const parameters = [];
+  for (const condition of conditions) {
+    const built = buildCondition(condition);
+    clauses.push(built.clause);
+    parameters.push(...built.parameters);
+  }
+  return {
+    whereClause: `WHERE ${clauses.join(" AND ")}`,
+    parameters
+  };
+};
+var buildCondition = (condition) => {
+  if (condition.type === "or") {
+    if (condition.conditions.length === 0) {
+      return { clause: "0 = 1", parameters: [] };
+    }
+    const subClauses = [];
+    const subParams = [];
+    for (const sub of condition.conditions) {
+      const built = buildCondition(sub);
+      subClauses.push(built.clause);
+      subParams.push(...built.parameters);
+    }
+    return { clause: `(${subClauses.join(" OR ")})`, parameters: subParams };
+  }
+  if (condition.type === "compoundEquals") {
+    const clauses = condition.columns.map((col2) => `${quoteIdentifier(col2)} = ?`);
+    return { clause: `(${clauses.join(" AND ")})`, parameters: condition.values };
+  }
+  const col = quoteIdentifier(condition.column);
+  switch (condition.type) {
+    case "equals": {
+      if (condition.caseInsensitive) {
+        return { clause: `LOWER(${col}) = LOWER(?)`, parameters: [condition.value] };
+      }
+      return { clause: `${col} = ?`, parameters: [condition.value] };
+    }
+    case "comparison": {
+      return { clause: `${col} ${condition.op} ?`, parameters: [condition.value] };
+    }
+    case "between": {
+      const lowerOp = condition.includeLower ? ">=" : ">";
+      const upperOp = condition.includeUpper ? "<=" : "<";
+      return {
+        clause: `(${col} ${lowerOp} ? AND ${col} ${upperOp} ?)`,
+        parameters: [condition.lower, condition.upper]
+      };
+    }
+    case "in": {
+      if (condition.values.length === 0) {
+        return { clause: "0 = 1", parameters: [] };
+      }
+      const placeholders = condition.values.map(() => "?").join(", ");
+      if (condition.caseInsensitive) {
+        return {
+          clause: `LOWER(${col}) IN (${condition.values.map(() => "LOWER(?)").join(", ")})`,
+          parameters: condition.values
+        };
+      }
+      return { clause: `${col} IN (${placeholders})`, parameters: condition.values };
+    }
+    case "notIn": {
+      if (condition.values.length === 0) {
+        return { clause: "1 = 1", parameters: [] };
+      }
+      const placeholders = condition.values.map(() => "?").join(", ");
+      return { clause: `${col} NOT IN (${placeholders})`, parameters: condition.values };
+    }
+    case "like": {
+      if (condition.caseInsensitive) {
+        return { clause: `LOWER(${col}) LIKE LOWER(?)`, parameters: [condition.pattern] };
+      }
+      return { clause: `${col} LIKE ?`, parameters: [condition.pattern] };
+    }
+  }
+};
+var cloneValue = (value) => {
+  if (typeof globalThis.structuredClone === "function") {
+    return globalThis.structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value ?? null));
+};
+var quoteIdentifier = (name) => `"${name.replace(/"/g, '""')}"`;
+var normalizeComparableValue = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeComparableValue(entry));
+  }
+  if (value instanceof Date) {
+    return value.valueOf();
+  }
+  if (value === void 0) {
+    return null;
+  }
+  return value;
+};
+
+// src/storage/sqlite/SqliteQueryContext.ts
+var SqliteQueryContext = class {
+  constructor(driver, adapter) {
+    this.driver = driver;
+    this.adapter = adapter;
+  }
+  table(name) {
+    return this.adapter.table(name);
+  }
+  transaction(mode, tableNames, callback) {
+    return this.adapter.transaction(mode, tableNames, callback);
+  }
+  async execute(statement) {
+    return this.driver.execute(statement);
+  }
+  async run(statement, values) {
+    return this.driver.run(statement, values);
+  }
+  async queryRows(statement, values) {
+    return this.adapter.queryRows(statement, values);
+  }
+};
+
+// src/storage/sqlite/SQLiteAdapter.ts
+var SQLiteAdapter2 = class {
+  type = "SQLiteAdapter";
+  name;
+  options;
+  schemas = /* @__PURE__ */ new Map();
+  versionSchemas = /* @__PURE__ */ new Map();
+  versionOptions = /* @__PURE__ */ new Map();
+  tableCache = /* @__PURE__ */ new Map();
+  driver;
+  openPromise;
+  isOpen = false;
+  schemaApplied = false;
+  transactionDepth = 0;
+  targetVersion = 0;
+  constructor(driver, options = {}) {
+    this.driver = driver;
+    this.name = driver.name;
+    this.options = options;
+  }
+  get driverType() {
+    return this.driver.type;
+  }
+  /**
+   * Opens the database connection and applies schema.
+   * This is called automatically when performing operations,
+   * so explicit calls are optional but safe (idempotent).
+   * When called explicitly after schema changes, it will run any pending migrations.
+   */
+  async open() {
+    if (this.isOpen) {
+      await this.runPendingMigrations();
+      return;
+    }
+    return this.ensureOpen();
+  }
+  async ensureOpen() {
+    if (this.isOpen) {
+      return;
+    }
+    if (this.openPromise) {
+      return this.openPromise;
+    }
+    this.openPromise = this.performOpen();
+    try {
+      await this.openPromise;
+    } finally {
+      this.openPromise = void 0;
+    }
+  }
+  async performOpen() {
+    await this.driver.open();
+    await this.applySchema();
+    await this.runPendingMigrations();
+    this.isOpen = true;
+  }
+  async close() {
+    if (this.driver) {
+      await this.driver.close();
+    }
+    this.isOpen = false;
+    this.tableCache.clear();
+  }
+  async delete() {
+    for (const table of this.schemas.keys()) {
+      await this.execute(`DROP TABLE IF EXISTS ${quoteIdentifier(table)}`);
+    }
+    await this.execute(`DROP TABLE IF EXISTS ${quoteIdentifier(DYNC_STATE_TABLE)}`);
+    this.tableCache.clear();
+    this.schemaApplied = false;
+    this.refreshActiveSchema();
+  }
+  defineSchema(version, schema, options) {
+    const normalized = /* @__PURE__ */ new Map();
+    for (const [tableName, definition] of Object.entries(schema)) {
+      if (typeof definition === "string") {
+        throw new Error(`SQLite adapter requires structured schema definitions. Table '${tableName}' must provide an object-based schema.`);
+      }
+      normalized.set(tableName, this.parseStructuredSchema(tableName, definition));
+    }
+    this.versionSchemas.set(version, normalized);
+    this.versionOptions.set(version, options ?? {});
+    this.refreshActiveSchema();
+  }
+  refreshActiveSchema() {
+    if (!this.versionSchemas.size) {
+      this.schemas.clear();
+      this.targetVersion = 0;
+      this.schemaApplied = false;
+      this.tableCache.clear();
+      return;
+    }
+    const versions = Array.from(this.versionSchemas.keys());
+    const latestVersion = Math.max(...versions);
+    const latestSchema = this.versionSchemas.get(latestVersion);
+    if (!latestSchema) {
+      return;
+    }
+    this.schemas.clear();
+    for (const [name, schema] of latestSchema.entries()) {
+      this.schemas.set(name, schema);
+    }
+    if (this.targetVersion !== latestVersion) {
+      this.tableCache.clear();
+    }
+    this.targetVersion = latestVersion;
+    this.schemaApplied = false;
+  }
+  table(name) {
+    if (!this.schemas.has(name)) {
+      throw new Error(`Table '${name}' is not part of the defined schema`);
+    }
+    if (!this.tableCache.has(name)) {
+      this.tableCache.set(name, new SQLiteTable(this, this.schemas.get(name)));
+    }
+    return this.tableCache.get(name);
+  }
+  async transaction(_mode, tableNames, callback) {
+    const driver = await this.getDriver();
+    const shouldManageTransaction = this.transactionDepth === 0;
+    this.transactionDepth += 1;
+    if (shouldManageTransaction) {
+      this.logSql("BEGIN TRANSACTION");
+      await driver.execute("BEGIN TRANSACTION");
+    }
+    try {
+      const tables = {};
+      for (const tableName of tableNames) {
+        tables[tableName] = this.table(tableName);
+      }
+      const result = await callback({ tables });
+      if (shouldManageTransaction) {
+        this.logSql("COMMIT");
+        await driver.execute("COMMIT");
+      }
+      return result;
+    } catch (err) {
+      if (shouldManageTransaction) {
+        this.logSql("ROLLBACK");
+        await driver.execute("ROLLBACK");
+      }
+      throw err;
+    } finally {
+      this.transactionDepth -= 1;
+    }
+  }
+  async execute(statement, values) {
+    if (values && values.length) {
+      await this.run(statement, values);
+      return;
+    }
+    const driver = await this.getDriver();
+    this.logSql(statement);
+    await driver.execute(statement);
+  }
+  async run(statement, values) {
+    const driver = await this.getDriver();
+    const params = values ?? [];
+    this.logSql(statement, params);
+    return driver.run(statement, params);
+  }
+  async query(arg1, arg2) {
+    if (typeof arg1 === "function") {
+      const driver2 = await this.getDriver();
+      return arg1(new SqliteQueryContext(driver2, this));
+    }
+    const statement = arg1;
+    const values = arg2;
+    const driver = await this.getDriver();
+    const params = values ?? [];
+    this.logSql(statement, params);
+    return driver.query(statement, params);
+  }
+  async queryRows(statement, values) {
+    const result = await this.query(statement, values);
+    const columns = result.columns ?? [];
+    return (result.values ?? []).map((row) => {
+      const record = {};
+      for (let index = 0; index < columns.length; index += 1) {
+        record[columns[index]] = row[index];
+      }
+      return record;
+    });
+  }
+  /**
+   * Ensures the database is open and returns the driver.
+   * This is the main entry point for all public database operations.
+   */
+  async getDriver() {
+    await this.ensureOpen();
+    return this.driver;
+  }
+  /**
+   * Internal execute that uses driver directly.
+   * Used during the open process to avoid recursion.
+   */
+  async internalExecute(statement, values) {
+    if (values && values.length) {
+      await this.internalRun(statement, values);
+      return;
+    }
+    this.logSql(statement);
+    await this.driver.execute(statement);
+  }
+  /**
+   * Internal run that uses driver directly.
+   * Used during the open process to avoid recursion.
+   */
+  async internalRun(statement, values) {
+    const params = values ?? [];
+    this.logSql(statement, params);
+    return this.driver.run(statement, params);
+  }
+  /**
+   * Internal queryRows that uses driver directly.
+   * Used during the open process to avoid recursion.
+   */
+  async internalQueryRows(statement, values) {
+    const params = values ?? [];
+    this.logSql(statement, params);
+    const result = await this.driver.query(statement, params);
+    const columns = result.columns ?? [];
+    return (result.values ?? []).map((row) => {
+      const record = {};
+      for (let index = 0; index < columns.length; index += 1) {
+        record[columns[index]] = row[index];
+      }
+      return record;
+    });
+  }
+  /**
+   * Internal query that uses driver directly.
+   * Used during migrations to avoid recursion.
+   */
+  async internalQuery(statement, values) {
+    const params = values ?? [];
+    this.logSql(statement, params);
+    return this.driver.query(statement, params);
+  }
+  logSql(statement, parameters) {
+    const { debug } = this.options;
+    if (!debug) {
+      return;
+    }
+    const hasParams = parameters && parameters.length;
+    if (typeof debug === "function") {
+      debug(statement, hasParams ? parameters : void 0);
+      return;
+    }
+    if (debug === true) {
+      if (hasParams) {
+        console.debug("[dync][sqlite]", statement, parameters);
+      } else {
+        console.debug("[dync][sqlite]", statement);
+      }
+    }
+  }
+  async getStoredSchemaVersion() {
+    const rows = await this.internalQueryRows(`SELECT value FROM ${quoteIdentifier(DYNC_STATE_TABLE)} WHERE ${quoteIdentifier(LOCAL_PK)} = ? LIMIT 1`, [
+      SQLITE_SCHEMA_VERSION_STATE_KEY
+    ]);
+    const rawValue = rows[0]?.value;
+    const parsed = Number(rawValue ?? 0);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  async setStoredSchemaVersion(version) {
+    await this.internalRun(
+      `INSERT INTO ${quoteIdentifier(DYNC_STATE_TABLE)} (${quoteIdentifier(LOCAL_PK)}, value) VALUES (?, ?) ON CONFLICT(${quoteIdentifier(LOCAL_PK)}) DO UPDATE SET value = excluded.value`,
+      [SQLITE_SCHEMA_VERSION_STATE_KEY, String(version)]
+    );
+  }
+  async runPendingMigrations() {
+    if (!this.versionSchemas.size) {
+      await this.setStoredSchemaVersion(0);
+      return;
+    }
+    const targetVersion = this.targetVersion;
+    const currentVersion = await this.getStoredSchemaVersion();
+    if (currentVersion === targetVersion) {
+      return;
+    }
+    if (currentVersion < targetVersion) {
+      for (let version = currentVersion + 1; version <= targetVersion; version += 1) {
+        await this.runMigrationStep(version, "upgrade", version - 1, version);
+        await this.setStoredSchemaVersion(version);
+      }
+      return;
+    }
+    for (let version = currentVersion; version > targetVersion; version -= 1) {
+      await this.runMigrationStep(version, "downgrade", version, version - 1);
+      await this.setStoredSchemaVersion(version - 1);
+    }
+  }
+  async runMigrationStep(version, direction, fromVersion, toVersion) {
+    const handler = this.getMigrationHandler(version, direction);
+    if (!handler) {
+      return;
+    }
+    const context = {
+      direction,
+      fromVersion,
+      toVersion,
+      execute: (statement) => this.internalExecute(statement),
+      run: (statement, values) => this.internalRun(statement, values),
+      query: (statement, values) => this.internalQuery(statement, values)
+    };
+    await handler(context);
+  }
+  getMigrationHandler(version, direction) {
+    const options = this.versionOptions.get(version);
+    const migrations = options?.sqlite?.migrations;
+    if (!migrations) {
+      return void 0;
+    }
+    return direction === "upgrade" ? migrations.upgrade : migrations.downgrade;
+  }
+  async applySchema() {
+    if (this.schemaApplied) {
+      return;
+    }
+    for (const schema of this.schemas.values()) {
+      await this.internalExecute(this.buildCreateTableStatement(schema));
+      const indexStatements = this.buildIndexStatements(schema);
+      for (const statement of indexStatements) {
+        await this.internalExecute(statement);
+      }
+    }
+    this.schemaApplied = true;
+  }
+  buildCreateTableStatement(schema) {
+    const columns = [];
+    for (const column of Object.values(schema.definition.columns)) {
+      columns.push(this.buildStructuredColumnDefinition(column));
+    }
+    if (schema.definition.source === "structured" && Array.isArray(schema.definition.tableConstraints)) {
+      columns.push(...schema.definition.tableConstraints.filter(Boolean));
+    }
+    const trailingClauses = [schema.definition.withoutRowId ? "WITHOUT ROWID" : void 0, schema.definition.strict ? "STRICT" : void 0].filter(Boolean);
+    const suffix = trailingClauses.length ? ` ${trailingClauses.join(" ")}` : "";
+    return `CREATE TABLE IF NOT EXISTS ${quoteIdentifier(schema.name)} (${columns.join(", ")})${suffix}`;
+  }
+  buildStructuredColumnDefinition(column) {
+    const parts = [];
+    parts.push(quoteIdentifier(column.name));
+    parts.push(this.formatColumnType(column));
+    if (column.name === LOCAL_PK) {
+      parts.push("PRIMARY KEY");
+    }
+    if (column.collate) {
+      parts.push(`COLLATE ${column.collate}`);
+    }
+    if (column.generatedAlwaysAs) {
+      const storage = column.stored ? "STORED" : "VIRTUAL";
+      parts.push(`GENERATED ALWAYS AS (${column.generatedAlwaysAs}) ${storage}`);
+    }
+    if (column.unique) {
+      parts.push("UNIQUE");
+    }
+    if (column.default !== void 0) {
+      parts.push(`DEFAULT ${this.formatDefaultValue(column.default)}`);
+    }
+    if (column.check) {
+      parts.push(`CHECK (${column.check})`);
+    }
+    if (column.references) {
+      parts.push(this.buildReferencesClause(column.references));
+    }
+    if (column.constraints?.length) {
+      parts.push(...column.constraints);
+    }
+    return parts.filter(Boolean).join(" ");
+  }
+  formatColumnType(column) {
+    const declaredType = column.type?.trim().toUpperCase();
+    const base = !declaredType || !declaredType.length ? "NUMERIC" : declaredType === "BOOLEAN" ? "INTEGER" : declaredType;
+    if (column.length && !base.includes("(")) {
+      return `${base}(${column.length})`;
+    }
+    return base;
+  }
+  formatDefaultValue(value) {
+    if (value === null) {
+      return "NULL";
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "boolean") {
+      return value ? "1" : "0";
+    }
+    const escaped = String(value).replace(/'/g, "''");
+    return `'${escaped}'`;
+  }
+  buildReferencesClause(reference) {
+    if (typeof reference === "string") {
+      return `REFERENCES ${reference}`;
+    }
+    const parts = [];
+    parts.push(`REFERENCES ${quoteIdentifier(reference.table)}`);
+    if (reference.column) {
+      parts.push(`(${quoteIdentifier(reference.column)})`);
+    }
+    if (reference.match) {
+      parts.push(`MATCH ${reference.match}`);
+    }
+    if (reference.onDelete) {
+      parts.push(`ON DELETE ${reference.onDelete}`);
+    }
+    if (reference.onUpdate) {
+      parts.push(`ON UPDATE ${reference.onUpdate}`);
+    }
+    return parts.join(" ");
+  }
+  buildIndexStatements(schema) {
+    if (schema.definition.source !== "structured" || !schema.definition.indexes?.length) {
+      return [];
+    }
+    const statements = [];
+    schema.definition.indexes.forEach((index, position) => {
+      if (!index.columns?.length) {
+        return;
+      }
+      const indexName = this.generateIndexName(schema, index, position);
+      const columnSegments = index.columns.map((columnName, columnIndex) => {
+        const segments = [quoteIdentifier(columnName)];
+        if (index.collate) {
+          segments.push(`COLLATE ${index.collate}`);
+        }
+        const order = index.orders?.[columnIndex];
+        if (order) {
+          segments.push(order);
+        }
+        return segments.join(" ");
+      });
+      const whereClause = index.where ? ` WHERE ${index.where}` : "";
+      statements.push(
+        `CREATE ${index.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${quoteIdentifier(indexName)} ON ${quoteIdentifier(schema.name)} (${columnSegments.join(", ")})${whereClause}`
+      );
+    });
+    return statements;
+  }
+  generateIndexName(schema, index, position) {
+    if (index.name) {
+      return index.name;
+    }
+    const sanitizedColumns = index.columns.map((column) => column.replace(/[^A-Za-z0-9_]/g, "_")).join("_");
+    const suffix = sanitizedColumns || String(position);
+    return `${schema.name}_${suffix}_idx`;
+  }
+  parseStructuredSchema(tableName, definition) {
+    if (!definition?.columns || !Object.keys(definition.columns).length) {
+      throw new Error(`SQLite schema for table '${tableName}' must define at least one column.`);
+    }
+    if (!definition.columns[LOCAL_PK]) {
+      throw new Error(`SQLite schema for table '${tableName}' must define a column named '${LOCAL_PK}'.`);
+    }
+    const normalizedColumns = this.normalizeColumns(definition.columns);
+    return {
+      name: tableName,
+      definition: {
+        ...definition,
+        name: tableName,
+        columns: normalizedColumns,
+        source: "structured"
+      }
+    };
+  }
+  normalizeColumns(columns) {
+    const normalized = {};
+    for (const [name, column] of Object.entries(columns)) {
+      normalized[name] = {
+        name,
+        ...column,
+        nullable: column?.nullable ?? true
+      };
+    }
+    return normalized;
+  }
+};
+
+// src/storage/sqlite/SQLiteWhereClause.ts
+var SQLiteWhereClause = class {
+  table;
+  index;
+  baseCollection;
+  constructor(table, index, baseCollection) {
+    this.table = table;
+    this.index = index;
+    this.baseCollection = baseCollection;
+  }
+  getColumn() {
+    if (Array.isArray(this.index)) {
+      return this.index[0];
+    }
+    return this.index;
+  }
+  isCompoundIndex() {
+    return Array.isArray(this.index) && this.index.length > 1;
+  }
+  getCompoundColumns() {
+    return Array.isArray(this.index) ? this.index : [this.index];
+  }
+  getCompoundValues(value) {
+    if (Array.isArray(value)) {
+      return value;
+    }
+    return [value];
+  }
+  createCollectionWithCondition(condition) {
+    const base = this.baseCollection ?? this.table.createCollection();
+    return base.addSqlCondition(condition);
+  }
+  createCollectionWithJsPredicate(predicate) {
+    const base = this.baseCollection ?? this.table.createCollection();
+    return base.jsFilter(predicate);
+  }
+  getIndexValue(record) {
+    return this.table.getIndexValue(record, this.index);
+  }
+  flattenArgs(args) {
+    if (args.length === 1 && Array.isArray(args[0])) {
+      return args[0];
+    }
+    return args;
+  }
+  equals(value) {
+    if (this.isCompoundIndex()) {
+      const columns = this.getCompoundColumns();
+      const values = this.getCompoundValues(value);
+      return this.createCollectionWithCondition({
+        type: "compoundEquals",
+        columns,
+        values
+      });
+    }
+    return this.createCollectionWithCondition({
+      type: "equals",
+      column: this.getColumn(),
+      value
+    });
+  }
+  above(value) {
+    if (this.isCompoundIndex()) {
+      return this.createCollectionWithJsPredicate((record) => this.table.compareValues(this.getIndexValue(record), value) > 0);
+    }
+    return this.createCollectionWithCondition({
+      type: "comparison",
+      column: this.getColumn(),
+      op: ">",
+      value
+    });
+  }
+  aboveOrEqual(value) {
+    if (this.isCompoundIndex()) {
+      return this.createCollectionWithJsPredicate((record) => this.table.compareValues(this.getIndexValue(record), value) >= 0);
+    }
+    return this.createCollectionWithCondition({
+      type: "comparison",
+      column: this.getColumn(),
+      op: ">=",
+      value
+    });
+  }
+  below(value) {
+    if (this.isCompoundIndex()) {
+      return this.createCollectionWithJsPredicate((record) => this.table.compareValues(this.getIndexValue(record), value) < 0);
+    }
+    return this.createCollectionWithCondition({
+      type: "comparison",
+      column: this.getColumn(),
+      op: "<",
+      value
+    });
+  }
+  belowOrEqual(value) {
+    if (this.isCompoundIndex()) {
+      return this.createCollectionWithJsPredicate((record) => this.table.compareValues(this.getIndexValue(record), value) <= 0);
+    }
+    return this.createCollectionWithCondition({
+      type: "comparison",
+      column: this.getColumn(),
+      op: "<=",
+      value
+    });
+  }
+  between(lower, upper, includeLower = true, includeUpper = false) {
+    if (this.isCompoundIndex()) {
+      return this.createCollectionWithJsPredicate((record) => {
+        const value = this.getIndexValue(record);
+        const lowerCmp = this.table.compareValues(value, lower);
+        const upperCmp = this.table.compareValues(value, upper);
+        const lowerPass = includeLower ? lowerCmp >= 0 : lowerCmp > 0;
+        const upperPass = includeUpper ? upperCmp <= 0 : upperCmp < 0;
+        return lowerPass && upperPass;
+      });
+    }
+    return this.createCollectionWithCondition({
+      type: "between",
+      column: this.getColumn(),
+      lower,
+      upper,
+      includeLower,
+      includeUpper
+    });
+  }
+  inAnyRange(ranges, options) {
+    if (this.isCompoundIndex() || ranges.length === 0) {
+      return this.createCollectionWithJsPredicate((record) => {
+        const value = this.getIndexValue(record);
+        return ranges.some(([lower, upper]) => {
+          const lowerCmp = this.table.compareValues(value, lower);
+          const upperCmp = this.table.compareValues(value, upper);
+          const lowerPass = options?.includeLower !== false ? lowerCmp >= 0 : lowerCmp > 0;
+          const upperPass = options?.includeUpper ? upperCmp <= 0 : upperCmp < 0;
+          return lowerPass && upperPass;
+        });
+      });
+    }
+    const column = this.getColumn();
+    const orConditions = ranges.map(([lower, upper]) => ({
+      type: "between",
+      column,
+      lower,
+      upper,
+      includeLower: options?.includeLower !== false,
+      includeUpper: options?.includeUpper ?? false
+    }));
+    return this.createCollectionWithCondition({
+      type: "or",
+      conditions: orConditions
+    });
+  }
+  startsWith(prefix) {
+    if (this.isCompoundIndex()) {
+      return this.createCollectionWithJsPredicate((record) => String(this.getIndexValue(record) ?? "").startsWith(prefix));
+    }
+    const escapedPrefix = prefix.replace(/[%_\\]/g, "\\$&");
+    return this.createCollectionWithCondition({
+      type: "like",
+      column: this.getColumn(),
+      pattern: `${escapedPrefix}%`
+    });
+  }
+  startsWithIgnoreCase(prefix) {
+    if (this.isCompoundIndex()) {
+      return this.createCollectionWithJsPredicate(
+        (record) => String(this.getIndexValue(record) ?? "").toLowerCase().startsWith(prefix.toLowerCase())
+      );
+    }
+    const escapedPrefix = prefix.replace(/[%_\\]/g, "\\$&");
+    return this.createCollectionWithCondition({
+      type: "like",
+      column: this.getColumn(),
+      pattern: `${escapedPrefix}%`,
+      caseInsensitive: true
+    });
+  }
+  startsWithAnyOf(...args) {
+    const prefixes = this.flattenArgs(args);
+    if (this.isCompoundIndex() || prefixes.length === 0) {
+      return this.createCollectionWithJsPredicate((record) => {
+        const value = String(this.getIndexValue(record) ?? "");
+        return prefixes.some((prefix) => value.startsWith(prefix));
+      });
+    }
+    const column = this.getColumn();
+    const orConditions = prefixes.map((prefix) => {
+      const escapedPrefix = prefix.replace(/[%_\\]/g, "\\$&");
+      return {
+        type: "like",
+        column,
+        pattern: `${escapedPrefix}%`
+      };
+    });
+    return this.createCollectionWithCondition({
+      type: "or",
+      conditions: orConditions
+    });
+  }
+  startsWithAnyOfIgnoreCase(...args) {
+    const prefixes = this.flattenArgs(args);
+    if (this.isCompoundIndex() || prefixes.length === 0) {
+      const lowerPrefixes = prefixes.map((p) => p.toLowerCase());
+      return this.createCollectionWithJsPredicate((record) => {
+        const value = String(this.getIndexValue(record) ?? "").toLowerCase();
+        return lowerPrefixes.some((prefix) => value.startsWith(prefix));
+      });
+    }
+    const column = this.getColumn();
+    const orConditions = prefixes.map((prefix) => {
+      const escapedPrefix = prefix.replace(/[%_\\]/g, "\\$&");
+      return {
+        type: "like",
+        column,
+        pattern: `${escapedPrefix}%`,
+        caseInsensitive: true
+      };
+    });
+    return this.createCollectionWithCondition({
+      type: "or",
+      conditions: orConditions
+    });
+  }
+  equalsIgnoreCase(value) {
+    if (this.isCompoundIndex()) {
+      return this.createCollectionWithJsPredicate((record) => String(this.getIndexValue(record) ?? "").toLowerCase() === value.toLowerCase());
+    }
+    return this.createCollectionWithCondition({
+      type: "equals",
+      column: this.getColumn(),
+      value,
+      caseInsensitive: true
+    });
+  }
+  anyOf(...args) {
+    const values = this.flattenArgs(args);
+    if (this.isCompoundIndex()) {
+      const columns = this.getCompoundColumns();
+      const orConditions = values.map((value) => ({
+        type: "compoundEquals",
+        columns,
+        values: this.getCompoundValues(value)
+      }));
+      return this.createCollectionWithCondition({
+        type: "or",
+        conditions: orConditions
+      });
+    }
+    return this.createCollectionWithCondition({
+      type: "in",
+      column: this.getColumn(),
+      values
+    });
+  }
+  anyOfIgnoreCase(...args) {
+    const values = this.flattenArgs(args);
+    if (this.isCompoundIndex()) {
+      const lowerValues = values.map((v) => v.toLowerCase());
+      return this.createCollectionWithJsPredicate((record) => {
+        const value = String(this.getIndexValue(record) ?? "").toLowerCase();
+        return lowerValues.includes(value);
+      });
+    }
+    return this.createCollectionWithCondition({
+      type: "in",
+      column: this.getColumn(),
+      values,
+      caseInsensitive: true
+    });
+  }
+  noneOf(...args) {
+    const values = this.flattenArgs(args);
+    if (this.isCompoundIndex()) {
+      return this.createCollectionWithJsPredicate(
+        (record) => values.every((candidate) => this.table.compareValues(this.getIndexValue(record), candidate) !== 0)
+      );
+    }
+    return this.createCollectionWithCondition({
+      type: "notIn",
+      column: this.getColumn(),
+      values
+    });
+  }
+  notEqual(value) {
+    if (this.isCompoundIndex()) {
+      return this.createCollectionWithJsPredicate((record) => this.table.compareValues(this.getIndexValue(record), value) !== 0);
+    }
+    return this.createCollectionWithCondition({
+      type: "comparison",
+      column: this.getColumn(),
+      op: "!=",
+      value
+    });
+  }
+};
+
+// src/storage/sqlite/SQLiteTable.ts
+var SQLiteTable = class {
+  name;
+  schema;
+  hook = Object.freeze({});
+  raw;
+  adapter;
+  columnNames;
+  booleanColumns;
+  constructor(adapter, schema) {
+    this.adapter = adapter;
+    this.schema = schema;
+    this.name = schema.name;
+    this.columnNames = Object.keys(schema.definition.columns ?? {});
+    this.booleanColumns = new Set(
+      Object.entries(schema.definition.columns ?? {}).filter(([_, col]) => col.type?.toUpperCase() === "BOOLEAN").map(([name]) => name)
+    );
+    this.raw = Object.freeze({
+      add: this.baseAdd.bind(this),
+      put: this.basePut.bind(this),
+      update: this.baseUpdate.bind(this),
+      delete: this.baseDelete.bind(this),
+      get: this.get.bind(this),
+      bulkAdd: this.baseBulkAdd.bind(this),
+      bulkPut: this.baseBulkPut.bind(this),
+      bulkUpdate: this.baseBulkUpdate.bind(this),
+      bulkDelete: this.baseBulkDelete.bind(this),
+      clear: this.baseClear.bind(this)
+    });
+  }
+  async add(item) {
+    return this.baseAdd(item);
+  }
+  async put(item) {
+    return this.basePut(item);
+  }
+  async update(key, changes) {
+    return this.baseUpdate(key, changes);
+  }
+  async delete(key) {
+    await this.baseDelete(key);
+  }
+  async clear() {
+    await this.baseClear();
+  }
+  async baseClear() {
+    await this.adapter.execute(`DELETE FROM ${quoteIdentifier(this.name)}`);
+  }
+  async get(key) {
+    if (!key || typeof key !== "string") {
+      return void 0;
+    }
+    const row = await this.fetchRow(key);
+    return row ? this.cloneRecord(row) : void 0;
+  }
+  async toArray() {
+    const entries = await this.getEntries();
+    return entries.map((entry) => this.cloneRecord(entry.value));
+  }
+  async count() {
+    const rows = await this.adapter.queryRows(`SELECT COUNT(*) as count FROM ${quoteIdentifier(this.name)}`);
+    return Number(rows[0]?.count ?? 0);
+  }
+  async bulkAdd(items) {
+    return this.baseBulkAdd(items);
+  }
+  async baseBulkAdd(items) {
+    if (!items.length) return void 0;
+    const columns = this.columnNames;
+    const columnCount = columns.length;
+    const maxParamsPerBatch = 500;
+    const batchSize = Math.max(1, Math.floor(maxParamsPerBatch / columnCount));
+    let lastKey = void 0;
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      const records = batch.map((item) => this.prepareRecordForWrite(item));
+      const placeholderRow = `(${columns.map(() => "?").join(", ")})`;
+      const placeholders = records.map(() => placeholderRow).join(", ");
+      const values = [];
+      for (const record of records) {
+        values.push(...this.extractColumnValues(record));
+      }
+      await this.adapter.run(
+        `INSERT INTO ${quoteIdentifier(this.name)} (${columns.map((c) => quoteIdentifier(c)).join(", ")}) VALUES ${placeholders}`,
+        values
+      );
+      lastKey = records[records.length - 1][LOCAL_PK];
+    }
+    return lastKey;
+  }
+  async bulkPut(items) {
+    return this.baseBulkPut(items);
+  }
+  async baseBulkPut(items) {
+    if (!items.length) return void 0;
+    const columns = this.columnNames;
+    const columnCount = columns.length;
+    const maxParamsPerBatch = 500;
+    const batchSize = Math.max(1, Math.floor(maxParamsPerBatch / columnCount));
+    let lastKey = void 0;
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      const records = batch.map((item) => this.prepareRecordForWrite(item));
+      const placeholderRow = `(${columns.map(() => "?").join(", ")})`;
+      const placeholders = records.map(() => placeholderRow).join(", ");
+      const values = [];
+      for (const record of records) {
+        values.push(...this.extractColumnValues(record));
+      }
+      await this.adapter.run(
+        `INSERT OR REPLACE INTO ${quoteIdentifier(this.name)} (${columns.map((c) => quoteIdentifier(c)).join(", ")}) VALUES ${placeholders}`,
+        values
+      );
+      lastKey = records[records.length - 1][LOCAL_PK];
+    }
+    return lastKey;
+  }
+  async bulkGet(keys) {
+    if (!keys.length) return [];
+    const validKeys = keys.filter((k) => k && typeof k === "string");
+    if (!validKeys.length) return keys.map(() => void 0);
+    const selectClause = this.buildSelectClause();
+    const placeholders = validKeys.map(() => "?").join(", ");
+    const rows = await this.adapter.queryRows(
+      `SELECT ${selectClause} FROM ${quoteIdentifier(this.name)} WHERE ${quoteIdentifier(LOCAL_PK)} IN (${placeholders})`,
+      validKeys
+    );
+    const recordMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const record = this.hydrateRow(row);
+      recordMap.set(String(row[LOCAL_PK]), this.cloneRecord(record));
+    }
+    return keys.map((key) => key && typeof key === "string" ? recordMap.get(key) : void 0);
+  }
+  async bulkUpdate(keysAndChanges) {
+    return this.baseBulkUpdate(keysAndChanges);
+  }
+  async baseBulkUpdate(keysAndChanges) {
+    if (!keysAndChanges.length) return 0;
+    let updatedCount = 0;
+    for (const { key, changes } of keysAndChanges) {
+      const result = await this.baseUpdate(key, changes);
+      updatedCount += result;
+    }
+    return updatedCount;
+  }
+  async bulkDelete(keys) {
+    await this.baseBulkDelete(keys);
+  }
+  async baseBulkDelete(keys) {
+    if (!keys.length) return;
+    const validKeys = keys.filter((k) => k && typeof k === "string");
+    if (!validKeys.length) return;
+    const placeholders = validKeys.map(() => "?").join(", ");
+    await this.adapter.run(`DELETE FROM ${quoteIdentifier(this.name)} WHERE ${quoteIdentifier(LOCAL_PK)} IN (${placeholders})`, validKeys);
+  }
+  where(index) {
+    return this.createWhereClause(index);
+  }
+  orderBy(index) {
+    return this.createCollection({
+      orderBy: { index, direction: "asc" }
+    });
+  }
+  reverse() {
+    return this.createCollection({ reverse: true });
+  }
+  offset(offset) {
+    return this.createCollection({ offset });
+  }
+  limit(count) {
+    return this.createCollection({ limit: count });
+  }
+  mapToClass(_ctor) {
+    return this;
+  }
+  async each(callback) {
+    const entries = await this.getEntries();
+    for (const entry of entries) {
+      await callback(this.cloneRecord(entry.value));
+    }
+  }
+  jsFilter(predicate) {
+    return this.createCollection({ jsPredicate: (record) => predicate(record) });
+  }
+  createCollection(stateOverrides) {
+    return new SQLiteCollection2(this, stateOverrides);
+  }
+  createCollectionFromPredicate(predicate, template) {
+    const baseState = template ? template.getState() : createDefaultState2();
+    const existingPredicate = baseState.jsPredicate;
+    const combinedPredicate = existingPredicate ? (record, key, index) => existingPredicate(record, key, index) && predicate(record, key, index) : predicate;
+    return new SQLiteCollection2(this, {
+      ...baseState,
+      jsPredicate: combinedPredicate
+    });
+  }
+  createWhereClause(index, baseCollection) {
+    return new SQLiteWhereClause(this, index, baseCollection);
+  }
+  async *iterateEntries(options) {
+    const selectClause = this.buildSelectClause();
+    const chunkSize = options?.chunkSize ?? DEFAULT_STREAM_BATCH_SIZE;
+    const orderClause = this.buildOrderByClause(options?.orderBy);
+    let offset = 0;
+    while (true) {
+      const statementParts = [`SELECT ${selectClause} FROM ${quoteIdentifier(this.name)}`];
+      if (orderClause) {
+        statementParts.push(orderClause);
+      }
+      statementParts.push(`LIMIT ${chunkSize} OFFSET ${offset}`);
+      const rows = await this.adapter.queryRows(statementParts.join(" "));
+      if (!rows.length) {
+        break;
+      }
+      for (const row of rows) {
+        yield { key: String(row[LOCAL_PK]), value: this.hydrateRow(row) };
+      }
+      if (rows.length < chunkSize) {
+        break;
+      }
+      offset += rows.length;
+    }
+  }
+  /**
+   * Execute a query with pre-built WHERE clause and parameters.
+   * This is used by SQLiteCollection for native SQL performance.
+   */
+  async queryWithConditions(options) {
+    const selectClause = this.buildSelectClause();
+    const distinctKeyword = options.distinct ? "DISTINCT " : "";
+    const parts = [`SELECT ${distinctKeyword}${selectClause} FROM ${quoteIdentifier(this.name)}`];
+    if (options.whereClause) {
+      parts.push(options.whereClause);
+    }
+    if (options.orderBy) {
+      parts.push(this.buildOrderByClause(options.orderBy));
+    }
+    if (options.limit !== void 0) {
+      parts.push(`LIMIT ${options.limit}`);
+    }
+    if (options.offset !== void 0 && options.offset > 0) {
+      parts.push(`OFFSET ${options.offset}`);
+    }
+    const rows = await this.adapter.queryRows(parts.join(" "), options.parameters);
+    return rows.map((row) => this.hydrateRow(row));
+  }
+  /**
+   * Execute a COUNT query with pre-built WHERE clause.
+   */
+  async countWithConditions(options) {
+    const distinctKeyword = options.distinct ? "DISTINCT " : "";
+    const selectClause = this.buildSelectClause();
+    const countExpr = options.distinct ? `COUNT(${distinctKeyword}${selectClause})` : "COUNT(*)";
+    const parts = [`SELECT ${countExpr} as count FROM ${quoteIdentifier(this.name)}`];
+    if (options.whereClause) {
+      parts.push(options.whereClause);
+    }
+    const rows = await this.adapter.queryRows(parts.join(" "), options.parameters);
+    return Number(rows[0]?.count ?? 0);
+  }
+  /**
+   * Execute a DELETE query with pre-built WHERE clause.
+   * Returns the number of deleted rows.
+   */
+  async deleteWithConditions(options) {
+    const parts = [`DELETE FROM ${quoteIdentifier(this.name)}`];
+    if (options.whereClause) {
+      parts.push(options.whereClause);
+    }
+    const result = await this.adapter.run(parts.join(" "), options.parameters);
+    return result.changes ?? 0;
+  }
+  /**
+   * Execute an UPDATE query with pre-built WHERE clause.
+   * Returns the number of updated rows.
+   */
+  async updateWithConditions(options) {
+    const changeEntries = Object.entries(options.changes);
+    if (changeEntries.length === 0) {
+      return 0;
+    }
+    const setClauses = changeEntries.map(([column]) => `${quoteIdentifier(column)} = ?`);
+    const setValues = changeEntries.map(([, value]) => this.normalizeColumnValue(value));
+    const parts = [`UPDATE ${quoteIdentifier(this.name)} SET ${setClauses.join(", ")}`];
+    if (options.whereClause) {
+      parts.push(options.whereClause);
+    }
+    const result = await this.adapter.run(parts.join(" "), [...setValues, ...options.parameters]);
+    return result.changes ?? 0;
+  }
+  /**
+   * Query only primary keys with pre-built WHERE clause.
+   * This is more efficient than fetching full rows when only keys are needed.
+   */
+  async queryKeysWithConditions(options) {
+    const distinctKeyword = options.distinct ? "DISTINCT " : "";
+    const parts = [`SELECT ${distinctKeyword}${quoteIdentifier(LOCAL_PK)} FROM ${quoteIdentifier(this.name)}`];
+    if (options.whereClause) {
+      parts.push(options.whereClause);
+    }
+    if (options.orderBy) {
+      parts.push(this.buildOrderByClause(options.orderBy));
+    }
+    if (options.limit !== void 0) {
+      parts.push(`LIMIT ${options.limit}`);
+    }
+    if (options.offset !== void 0 && options.offset > 0) {
+      parts.push(`OFFSET ${options.offset}`);
+    }
+    const rows = await this.adapter.queryRows(parts.join(" "), options.parameters);
+    return rows.map((row) => String(row[LOCAL_PK]));
+  }
+  async getEntries() {
+    const entries = [];
+    for await (const entry of this.iterateEntries()) {
+      entries.push(entry);
+    }
+    return entries;
+  }
+  cloneRecord(record) {
+    return cloneValue(record);
+  }
+  compareValues(left, right) {
+    const normalizedLeft = normalizeComparableValue(left);
+    const normalizedRight = normalizeComparableValue(right);
+    if (normalizedLeft < normalizedRight) return -1;
+    if (normalizedLeft > normalizedRight) return 1;
+    return 0;
+  }
+  compareByIndex(left, right, index) {
+    if (Array.isArray(index)) {
+      for (const key of index) {
+        const diff = this.compareValues(left[key], right[key]);
+        if (diff !== 0) {
+          return diff;
+        }
+      }
+      return 0;
+    }
+    return this.compareValues(left[index], right[index]);
+  }
+  getIndexValue(record, index) {
+    if (Array.isArray(index)) {
+      return index.map((key) => record[key]);
+    }
+    return record[index];
+  }
+  async replaceRecord(record) {
+    if (!this.columnNames.length) {
+      return;
+    }
+    const assignments = this.columnNames.map((column) => `${quoteIdentifier(column)} = ?`).join(", ");
+    const values = this.extractColumnValues(record);
+    await this.adapter.run(`UPDATE ${quoteIdentifier(this.name)} SET ${assignments} WHERE ${quoteIdentifier(LOCAL_PK)} = ?`, [
+      ...values,
+      record[LOCAL_PK]
+    ]);
+  }
+  async deleteByPrimaryKey(primaryKey) {
+    await this.adapter.run(`DELETE FROM ${quoteIdentifier(this.name)} WHERE ${quoteIdentifier(LOCAL_PK)} = ?`, [primaryKey]);
+  }
+  async baseAdd(item) {
+    const record = this.prepareRecordForWrite(item);
+    const columns = this.columnNames;
+    const placeholders = columns.map(() => "?").join(", ");
+    const values = this.extractColumnValues(record);
+    await this.adapter.run(
+      `INSERT INTO ${quoteIdentifier(this.name)} (${columns.map((column) => quoteIdentifier(column)).join(", ")}) VALUES (${placeholders})`,
+      values
+    );
+    return record[LOCAL_PK];
+  }
+  async basePut(item) {
+    const record = this.prepareRecordForWrite(item);
+    const columns = this.columnNames;
+    const placeholders = columns.map(() => "?").join(", ");
+    const values = this.extractColumnValues(record);
+    await this.adapter.run(
+      `INSERT OR REPLACE INTO ${quoteIdentifier(this.name)} (${columns.map((column) => quoteIdentifier(column)).join(", ")}) VALUES (${placeholders})`,
+      values
+    );
+    return record[LOCAL_PK];
+  }
+  async baseUpdate(key, changes) {
+    if (!key || typeof key !== "string") {
+      return 0;
+    }
+    const existing = await this.fetchRow(key);
+    if (!existing) {
+      return 0;
+    }
+    const updated = { ...existing, ...changes };
+    await this.replaceRecord(updated);
+    return 1;
+  }
+  async baseDelete(key) {
+    if (!key || typeof key !== "string") {
+      return;
+    }
+    await this.deleteByPrimaryKey(key);
+  }
+  prepareRecordForWrite(item) {
+    const clone = this.cloneRecord(item);
+    const primaryValue = clone[LOCAL_PK];
+    if (!primaryValue || typeof primaryValue !== "string") {
+      throw new Error(`Missing required primary key field "${LOCAL_PK}" - a string value must be provided`);
+    }
+    return clone;
+  }
+  async fetchRow(primaryKey) {
+    const selectClause = this.buildSelectClause();
+    const rows = await this.adapter.queryRows(`SELECT ${selectClause} FROM ${quoteIdentifier(this.name)} WHERE ${quoteIdentifier(LOCAL_PK)} = ? LIMIT 1`, [
+      primaryKey
+    ]);
+    if (!rows.length) {
+      return void 0;
+    }
+    return this.hydrateRow(rows[0]);
+  }
+  buildSelectClause() {
+    const dataColumns = this.columnNames.map((column) => quoteIdentifier(column));
+    return dataColumns.join(", ");
+  }
+  hydrateRow(row) {
+    const record = {};
+    for (const column of this.columnNames) {
+      let value = row[column];
+      if (this.booleanColumns.has(column) && value !== null && value !== void 0) {
+        value = value === 1 || value === true;
+      }
+      record[column] = value;
+    }
+    return record;
+  }
+  buildOrderByClause(orderBy) {
+    const target = orderBy ?? { index: LOCAL_PK, direction: "asc" };
+    const columns = Array.isArray(target.index) ? target.index : [target.index];
+    const direction = target.direction.toUpperCase();
+    const clause = columns.map((column) => `${quoteIdentifier(column)} ${direction}`).join(", ");
+    return `ORDER BY ${clause}`;
+  }
+  extractColumnValues(record) {
+    return this.columnNames.map((column) => this.normalizeColumnValue(record[column]));
+  }
+  normalizeColumnValue(value) {
+    if (value === void 0) {
+      return null;
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "boolean") {
+      return value ? 1 : 0;
+    }
+    return value;
+  }
+};
+
+// src/storage/sqlite/SQLiteCollection.ts
+var SQLiteCollection2 = class _SQLiteCollection {
+  table;
+  state;
+  constructor(table, state) {
+    this.table = table;
+    const base = createDefaultState2();
+    this.state = {
+      ...base,
+      ...state,
+      sqlConditions: state?.sqlConditions ?? base.sqlConditions,
+      jsPredicate: state?.jsPredicate
+    };
+  }
+  getState() {
+    return { ...this.state, sqlConditions: [...this.state.sqlConditions] };
+  }
+  // Add a SQL-expressible condition to this collection
+  addSqlCondition(condition) {
+    return new _SQLiteCollection(this.table, {
+      ...this.state,
+      sqlConditions: [...this.state.sqlConditions, condition]
+    });
+  }
+  replicate(overrides) {
+    return new _SQLiteCollection(this.table, {
+      ...this.state,
+      ...overrides,
+      sqlConditions: overrides?.sqlConditions ?? this.state.sqlConditions,
+      jsPredicate: overrides?.jsPredicate !== void 0 ? overrides.jsPredicate : this.state.jsPredicate
+    });
+  }
+  withJsPredicate(predicate) {
+    const existingPredicate = this.state.jsPredicate;
+    const combined = existingPredicate ? (record, key, index) => existingPredicate(record, key, index) && predicate(record, key, index) : predicate;
+    return new _SQLiteCollection(this.table, {
+      ...this.state,
+      jsPredicate: combined
+    });
+  }
+  hasJsPredicate() {
+    return this.state.jsPredicate !== void 0;
+  }
+  resolveOrdering() {
+    const base = this.state.orderBy ?? { index: LOCAL_PK, direction: "asc" };
+    const direction = this.state.reverse ? base.direction === "asc" ? "desc" : "asc" : base.direction;
+    return { index: base.index, direction };
+  }
+  /**
+   * Execute a native SQL query with all SQL conditions.
+   * If there's a JS predicate, we fetch rows without LIMIT/OFFSET in SQL
+   * and apply them after JS filtering.
+   */
+  async executeQuery(options = {}) {
+    const { whereClause, parameters } = buildWhereClause(this.state.sqlConditions);
+    const ordering = options.orderByOverride ?? this.resolveOrdering();
+    const cloneValues = options.clone !== false;
+    const hasJsFilter = this.hasJsPredicate();
+    const distinct = this.state.distinct;
+    const sqlLimit = hasJsFilter ? void 0 : options.limitOverride ?? this.state.limit;
+    const sqlOffset = hasJsFilter ? void 0 : this.state.offset;
+    const rows = await this.table.queryWithConditions({
+      whereClause,
+      parameters,
+      orderBy: ordering,
+      limit: sqlLimit,
+      offset: sqlOffset,
+      distinct
+    });
+    let results = rows.map((row) => ({
+      key: String(row[LOCAL_PK]),
+      value: row
+    }));
+    if (hasJsFilter) {
+      const predicate = this.state.jsPredicate;
+      results = results.filter((entry, index) => predicate(entry.value, entry.key, index));
+      const offset = Math.max(0, this.state.offset ?? 0);
+      const limit = options.limitOverride ?? this.state.limit;
+      if (offset > 0 || limit !== void 0) {
+        const end = limit !== void 0 ? offset + limit : void 0;
+        results = results.slice(offset, end);
+      }
+    }
+    if (cloneValues) {
+      results = results.map((entry) => ({
+        key: entry.key,
+        value: this.table.cloneRecord(entry.value)
+      }));
+    }
+    return results;
+  }
+  async first() {
+    const entries = await this.executeQuery({ limitOverride: 1 });
+    return entries[0]?.value;
+  }
+  async last() {
+    return this.replicate({ reverse: !this.state.reverse }).first();
+  }
+  async each(callback) {
+    const entries = await this.executeQuery();
+    for (const [index, entry] of entries.entries()) {
+      await callback(entry.value, index);
+    }
+  }
+  async eachKey(callback) {
+    const entries = await this.executeQuery({ clone: false });
+    for (const [index, entry] of entries.entries()) {
+      await callback(entry.key, index);
+    }
+  }
+  async eachPrimaryKey(callback) {
+    return this.eachKey(callback);
+  }
+  async eachUniqueKey(callback) {
+    const keys = await this.uniqueKeys();
+    for (let index = 0; index < keys.length; index += 1) {
+      await callback(keys[index], index);
+    }
+  }
+  async keys() {
+    if (!this.hasJsPredicate()) {
+      const { whereClause, parameters } = buildWhereClause(this.state.sqlConditions);
+      const ordering = this.resolveOrdering();
+      return this.table.queryKeysWithConditions({
+        whereClause,
+        parameters,
+        orderBy: ordering,
+        limit: this.state.limit,
+        offset: this.state.offset,
+        distinct: this.state.distinct
+      });
+    }
+    const entries = await this.executeQuery({ clone: false });
+    return entries.map((entry) => entry.key);
+  }
+  async primaryKeys() {
+    return this.keys();
+  }
+  async uniqueKeys() {
+    if (!this.hasJsPredicate()) {
+      const { whereClause, parameters } = buildWhereClause(this.state.sqlConditions);
+      const ordering = this.resolveOrdering();
+      return this.table.queryKeysWithConditions({
+        whereClause,
+        parameters,
+        orderBy: ordering,
+        limit: this.state.limit,
+        offset: this.state.offset,
+        distinct: true
+      });
+    }
+    const keys = await this.keys();
+    return [...new Set(keys)];
+  }
+  async count() {
+    if (!this.hasJsPredicate()) {
+      return this.table.countWithConditions({
+        whereClause: buildWhereClause(this.state.sqlConditions).whereClause,
+        parameters: buildWhereClause(this.state.sqlConditions).parameters,
+        distinct: this.state.distinct
+      });
+    }
+    const entries = await this.executeQuery({ clone: false });
+    return entries.length;
+  }
+  async sortBy(key) {
+    const entries = await this.executeQuery({
+      orderByOverride: { index: key, direction: "asc" }
+    });
+    return entries.map((entry) => entry.value);
+  }
+  distinct() {
+    return this.replicate({ distinct: true });
+  }
+  jsFilter(predicate) {
+    return this.withJsPredicate((record) => predicate(cloneValue(record)));
+  }
+  or(index) {
+    return this.table.createWhereClause(index, this);
+  }
+  clone(_props) {
+    return this.replicate();
+  }
+  reverse() {
+    return this.replicate({ reverse: !this.state.reverse });
+  }
+  offset(offset) {
+    return this.replicate({ offset });
+  }
+  limit(count) {
+    return this.replicate({ limit: count });
+  }
+  toCollection() {
+    return this.replicate();
+  }
+  async delete() {
+    if (!this.hasJsPredicate()) {
+      const { whereClause, parameters } = buildWhereClause(this.state.sqlConditions);
+      return this.table.deleteWithConditions({ whereClause, parameters });
+    }
+    const entries = await this.executeQuery({ clone: false });
+    for (const entry of entries) {
+      await this.table.deleteByPrimaryKey(entry.key);
+    }
+    return entries.length;
+  }
+  async modify(changes) {
+    if (typeof changes !== "function" && !this.hasJsPredicate()) {
+      const { whereClause, parameters } = buildWhereClause(this.state.sqlConditions);
+      return this.table.updateWithConditions({ whereClause, parameters, changes });
+    }
+    const entries = await this.executeQuery();
+    for (const entry of entries) {
+      const draft = cloneValue(entry.value);
+      if (typeof changes === "function") {
+        await changes(draft);
+      } else {
+        Object.assign(draft, changes);
+      }
+      await this.table.replaceRecord(draft);
+    }
+    return entries.length;
+  }
+  async toArray() {
+    const entries = await this.executeQuery();
+    return entries.map((entry) => entry.value);
+  }
+};
+
+export {
+  SyncAction,
+  createLocalId,
+  Dync,
+  MemoryQueryContext,
+  MemoryAdapter,
+  SqliteQueryContext,
+  SQLiteAdapter2 as SQLiteAdapter
+};
+//# sourceMappingURL=chunk-LGHOZECP.js.map