@tanstack/db-sqlite-persistence-core 0.1.2

package/dist/cjs/persisted.cjs

@@ -0,0 +1,1705 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const db = require("@tanstack/db");
+const errors = require("./errors.cjs");
+const REQUIRED_COORDINATOR_METHODS = [
+  `getNodeId`,
+  `subscribe`,
+  `publish`,
+  `isLeader`,
+  `ensureLeadership`,
+  `requestEnsurePersistedIndex`
+];
+const REQUIRED_ADAPTER_METHODS = [`loadSubset`, `applyCommittedTx`, `ensureIndex`];
+const TARGETED_INVALIDATION_KEY_LIMIT = 128;
+const DEFAULT_DB_NAME = `tanstack-db`;
+const REMOTE_ENSURE_RETRY_DELAY_MS = 50;
+class SingleProcessCoordinator {
+  constructor(nodeId = crypto.randomUUID()) {
+    this.nodeId = nodeId;
+  }
+  getNodeId() {
+    return this.nodeId;
+  }
+  subscribe() {
+    return () => {
+    };
+  }
+  publish() {
+  }
+  isLeader() {
+    return true;
+  }
+  async ensureLeadership() {
+  }
+  async requestEnsureRemoteSubset() {
+  }
+  async requestEnsurePersistedIndex() {
+  }
+  pullSince() {
+    return Promise.resolve({
+      type: `rpc:pullSince:res`,
+      rpcId: crypto.randomUUID(),
+      ok: true,
+      latestTerm: 1,
+      latestSeq: 0,
+      latestRowVersion: 0,
+      requiresFullReload: false,
+      changedKeys: [],
+      deletedKeys: [],
+      deltas: []
+    });
+  }
+}
+function validatePersistedCollectionCoordinator(coordinator) {
+  for (const method of REQUIRED_COORDINATOR_METHODS) {
+    if (typeof coordinator[method] !== `function`) {
+      throw new errors.InvalidPersistedCollectionCoordinatorError(method);
+    }
+  }
+}
+function validatePersistenceAdapter(adapter) {
+  for (const method of REQUIRED_ADAPTER_METHODS) {
+    if (typeof adapter[method] !== `function`) {
+      throw new errors.InvalidPersistenceAdapterError(method);
+    }
+  }
+}
+function resolvePersistence(persistence) {
+  validatePersistenceAdapter(persistence.adapter);
+  const coordinator = persistence.coordinator ?? new SingleProcessCoordinator();
+  validatePersistedCollectionCoordinator(coordinator);
+  return {
+    ...persistence,
+    coordinator
+  };
+}
+function resolvePersistenceForMode(persistence, mode) {
+  const modeSpecificPersistence = persistence.resolvePersistenceForMode?.(mode);
+  return resolvePersistence(modeSpecificPersistence ?? persistence);
+}
+function resolvePersistenceForCollection(persistence, options) {
+  const collectionSpecificPersistence = persistence.resolvePersistenceForCollection?.(options);
+  if (collectionSpecificPersistence) {
+    return resolvePersistence(collectionSpecificPersistence);
+  }
+  return resolvePersistenceForMode(persistence, options.mode);
+}
+function hasOwnSyncKey(options) {
+  return Object.prototype.hasOwnProperty.call(options, `sync`);
+}
+function isRecord(value) {
+  return typeof value === `object` && value !== null;
+}
+function isValidSyncConfig(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.sync === `function`;
+}
+class ApplyMutex {
+  constructor() {
+    this.queue = Promise.resolve();
+  }
+  async run(task) {
+    const taskPromise = this.queue.then(() => task());
+    this.queue = taskPromise.then(
+      () => void 0,
+      () => void 0
+    );
+    return taskPromise;
+  }
+}
+function toStableSerializable(value) {
+  if (value == null) {
+    return value;
+  }
+  switch (typeof value) {
+    case `string`:
+    case `number`:
+    case `boolean`:
+      return value;
+    case `bigint`:
+      return value.toString();
+    case `function`:
+    case `symbol`:
+    case `undefined`:
+      return void 0;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => toStableSerializable(entry)).filter((entry) => entry !== void 0);
+  }
+  if (value instanceof Set) {
+    return Array.from(value).map((entry) => toStableSerializable(entry)).filter((entry) => entry !== void 0).sort((left, right) => {
+      const leftSerialized = JSON.stringify(left);
+      const rightSerialized = JSON.stringify(right);
+      return leftSerialized < rightSerialized ? -1 : leftSerialized > rightSerialized ? 1 : 0;
+    });
+  }
+  if (value instanceof Map) {
+    return Array.from(value.entries()).map(([key, mapValue]) => ({
+      key: toStableSerializable(key),
+      value: toStableSerializable(mapValue)
+    })).filter((entry) => entry.key !== void 0 && entry.value !== void 0).sort((left, right) => {
+      const leftSerialized = JSON.stringify(left.key);
+      const rightSerialized = JSON.stringify(right.key);
+      return leftSerialized < rightSerialized ? -1 : leftSerialized > rightSerialized ? 1 : 0;
+    });
+  }
+  const record = value;
+  const orderedKeys = Object.keys(record).sort(
+    (left, right) => left < right ? -1 : left > right ? 1 : 0
+  );
+  const serializableRecord = {};
+  for (const key of orderedKeys) {
+    const serializableValue = toStableSerializable(record[key]);
+    if (serializableValue !== void 0) {
+      serializableRecord[key] = serializableValue;
+    }
+  }
+  return serializableRecord;
+}
+function stableSerialize(value) {
+  return JSON.stringify(toStableSerializable(value) ?? null);
+}
+function normalizeSubsetOptionsForKey(options) {
+  return {
+    where: toStableSerializable(options.where),
+    orderBy: toStableSerializable(options.orderBy),
+    limit: options.limit,
+    cursor: toStableSerializable(options.cursor),
+    offset: options.offset
+  };
+}
+function normalizeSyncFnResult(result) {
+  if (typeof result === `function`) {
+    return { cleanup: result };
+  }
+  if (result === void 0) {
+    return {};
+  }
+  return result;
+}
+function isTxCommittedPayload(payload) {
+  if (!isRecord(payload) || payload.type !== `tx:committed`) {
+    return false;
+  }
+  if (typeof payload.term !== `number` || typeof payload.seq !== `number` || typeof payload.txId !== `string` || typeof payload.latestRowVersion !== `number` || typeof payload.requiresFullReload !== `boolean`) {
+    return false;
+  }
+  if (payload.requiresFullReload) {
+    return true;
+  }
+  return Array.isArray(payload.changedRows) && Array.isArray(payload.deletedKeys) && (payload.rowMetadataMutations === void 0 || Array.isArray(payload.rowMetadataMutations)) && (payload.collectionMetadataMutations === void 0 || Array.isArray(payload.collectionMetadataMutations));
+}
+function isCollectionResetPayload(payload) {
+  return isRecord(payload) && payload.type === `collection:reset` && typeof payload.schemaVersion === `number` && typeof payload.resetEpoch === `number`;
+}
+function toPersistedMutationEnvelope(mutation) {
+  const key = mutation.key;
+  const value = mutation.type === `delete` ? mutation.original : mutation.modified;
+  return {
+    mutationId: mutation.mutationId,
+    type: mutation.type,
+    key,
+    value
+  };
+}
+class PersistedCollectionRuntime {
+  constructor(mode, collectionId, persistence, syncMode, dbName) {
+    this.mode = mode;
+    this.collectionId = collectionId;
+    this.persistence = persistence;
+    this.syncMode = syncMode;
+    this.dbName = dbName;
+    this.applyMutex = new ApplyMutex();
+    this.activeSubsets = /* @__PURE__ */ new Map();
+    this.pendingRemoteSubsetEnsures = /* @__PURE__ */ new Map();
+    this.queuedHydrationTransactions = [];
+    this.queuedTxCommitted = [];
+    this.subscriptionIds = /* @__PURE__ */ new WeakMap();
+    this.collection = null;
+    this.syncControls = {
+      begin: null,
+      write: null,
+      commit: null,
+      truncate: null,
+      metadata: null
+    };
+    this.started = false;
+    this.startupMetadataPromise = null;
+    this.startPromise = null;
+    this.internalApplyDepth = 0;
+    this.isHydrating = false;
+    this.coordinatorUnsubscribe = null;
+    this.indexAddedUnsubscribe = null;
+    this.indexRemovedUnsubscribe = null;
+    this.remoteEnsureRetryTimer = null;
+    this.nextSubscriptionId = 0;
+    this.latestTerm = 0;
+    this.latestSeq = 0;
+    this.latestRowVersion = 0;
+    this.localTerm = 1;
+    this.localSeq = 0;
+    this.localRowVersion = 0;
+  }
+  setSyncControls(syncControls) {
+    this.syncControls = syncControls;
+  }
+  clearSyncControls() {
+    this.syncControls = {
+      begin: null,
+      write: null,
+      commit: null,
+      truncate: null,
+      metadata: null
+    };
+  }
+  isHydratingNow() {
+    return this.isHydrating;
+  }
+  isApplyingInternally() {
+    return this.internalApplyDepth > 0;
+  }
+  setCollection(collection) {
+    if (this.collection === collection) {
+      return;
+    }
+    this.collection = collection;
+    this.attachCoordinatorSubscription();
+  }
+  getLeadershipState() {
+    return {
+      nodeId: this.persistence.coordinator.getNodeId(),
+      isLeader: this.persistence.coordinator.isLeader(this.collectionId)
+    };
+  }
+  async ensureStarted() {
+    if (this.startPromise) {
+      return this.startPromise;
+    }
+    this.startPromise = this.startInternal();
+    return this.startPromise;
+  }
+  async ensureStartupMetadataLoaded() {
+    if (this.startupMetadataPromise) {
+      return this.startupMetadataPromise;
+    }
+    this.startupMetadataPromise = this.loadStartupMetadataInternal();
+    return this.startupMetadataPromise;
+  }
+  async startInternal() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+    await this.ensureStartupMetadataLoaded();
+    const indexBootstrapSnapshot = this.collection?.getIndexMetadata() ?? [];
+    this.attachIndexLifecycleListeners();
+    await this.bootstrapPersistedIndexes(indexBootstrapSnapshot);
+    if (this.syncMode !== `on-demand`) {
+      this.activeSubsets.set(this.getSubsetKey({}), {});
+      await this.applyMutex.run(
+        () => this.hydrateSubsetUnsafe({}, { requestRemoteEnsure: false })
+      );
+    }
+  }
+  async loadStartupMetadataInternal() {
+    if (this.persistence.adapter.getStreamPosition) {
+      const position = await this.persistence.adapter.getStreamPosition(
+        this.collectionId
+      );
+      this.observeStreamPosition(
+        position.latestTerm,
+        position.latestSeq,
+        position.latestRowVersion
+      );
+    }
+    await this.loadCollectionMetadataIntoCollection();
+  }
+  async loadCollectionMetadataIntoCollection() {
+    const collectionMetadata = await this.loadCollectionMetadataSnapshot();
+    this.replaceCollectionMetadataSnapshot(collectionMetadata);
+  }
+  async loadCollectionMetadataSnapshot() {
+    if (!this.persistence.adapter.loadCollectionMetadata) {
+      return [];
+    }
+    return this.persistence.adapter.loadCollectionMetadata(this.collectionId);
+  }
+  replaceCollectionMetadataSnapshot(collectionMetadata) {
+    if (!this.syncControls.begin || !this.syncControls.commit || !this.syncControls.metadata) {
+      return;
+    }
+    const nextMetadata = new Map(
+      collectionMetadata.map(({ key, value }) => [key, value])
+    );
+    const currentKeys = this.syncControls.metadata.collection.list().map(({ key }) => key);
+    this.withInternalApply(() => {
+      this.syncControls.begin?.({ immediate: true });
+      currentKeys.forEach((key) => {
+        if (!nextMetadata.has(key)) {
+          this.syncControls.metadata?.collection.delete(key);
+        }
+      });
+      nextMetadata.forEach((value, key) => {
+        this.syncControls.metadata?.collection.set(key, value);
+      });
+      this.syncControls.commit?.();
+    });
+  }
+  async loadSubset(options, upstreamLoadSubset) {
+    this.activeSubsets.set(this.getSubsetKey(options), options);
+    await this.applyMutex.run(
+      () => this.hydrateSubsetUnsafe(options, {
+        requestRemoteEnsure: this.mode === `sync-present`
+      })
+    );
+    if (upstreamLoadSubset) {
+      try {
+        const maybePromise = upstreamLoadSubset(options);
+        if (maybePromise instanceof Promise) {
+          maybePromise.catch((error) => {
+            console.warn(
+              `Failed to load remote subset in persisted wrapper:`,
+              error
+            );
+            this.queueRemoteSubsetEnsure(options);
+          });
+        }
+      } catch (error) {
+        console.warn(`Failed to trigger remote subset load:`, error);
+        this.queueRemoteSubsetEnsure(options);
+      }
+    }
+  }
+  unloadSubset(options, upstreamUnloadSubset) {
+    this.activeSubsets.delete(this.getSubsetKey(options));
+    upstreamUnloadSubset?.(options);
+  }
+  async forceReloadSubset(options) {
+    this.activeSubsets.set(this.getSubsetKey(options), options);
+    await this.applyMutex.run(
+      () => this.hydrateSubsetUnsafe(options, { requestRemoteEnsure: false })
+    );
+  }
+  queueHydrationBufferedTransaction(transaction) {
+    this.queuedHydrationTransactions.push(transaction);
+  }
+  async persistAndBroadcastExternalSyncTransaction(transaction) {
+    await this.applyMutex.run(
+      () => this.persistAndBroadcastExternalSyncTransactionUnsafe(transaction)
+    );
+  }
+  normalizeSyncWriteMessage(message) {
+    if (!this.collection) {
+      throw new errors.InvalidPersistedCollectionConfigError(
+        `collection must be attached before sync writes are processed`
+      );
+    }
+    if (`key` in message) {
+      const key2 = message.key;
+      const previousValue = this.collection.get(key2) ?? {};
+      return {
+        forwardMessage: {
+          type: `delete`,
+          key: key2
+        },
+        operation: {
+          type: `delete`,
+          key: key2,
+          value: previousValue
+        }
+      };
+    }
+    if (message.type === `delete`) {
+      const key2 = this.collection.getKeyFromItem(message.value);
+      const previousValue = this.collection.get(key2) ?? message.value;
+      return {
+        forwardMessage: {
+          type: `delete`,
+          key: key2
+        },
+        operation: {
+          type: `delete`,
+          key: key2,
+          value: previousValue
+        }
+      };
+    }
+    const key = this.collection.getKeyFromItem(message.value);
+    return {
+      forwardMessage: {
+        type: `update`,
+        value: message.value,
+        metadata: message.metadata
+      },
+      operation: {
+        type: `update`,
+        key,
+        value: message.value,
+        metadata: message.metadata
+      }
+    };
+  }
+  async persistAndConfirmCollectionMutations(mutations) {
+    if (mutations.length === 0) {
+      return;
+    }
+    await this.applyMutex.run(async () => {
+      const acceptedMutationIds = await this.persistCollectionMutationsUnsafe(mutations);
+      const acceptedMutationIdSet = new Set(acceptedMutationIds);
+      const acceptedMutations = mutations.filter(
+        (mutation) => acceptedMutationIdSet.has(mutation.mutationId)
+      );
+      if (acceptedMutations.length !== mutations.length) {
+        throw new Error(
+          `persistence coordinator accepted ${acceptedMutations.length} of ${mutations.length} mutations; partial acceptance is not supported`
+        );
+      }
+      this.confirmMutationsSyncUnsafe(acceptedMutations);
+    });
+  }
+  async acceptTransactionMutations(transaction) {
+    const collectionMutations = this.filterMutationsForCollection(
+      transaction.mutations
+    );
+    if (collectionMutations.length === 0) {
+      return;
+    }
+    await this.persistAndConfirmCollectionMutations(collectionMutations);
+  }
+  cleanup() {
+    this.coordinatorUnsubscribe?.();
+    this.coordinatorUnsubscribe = null;
+    this.indexAddedUnsubscribe?.();
+    this.indexAddedUnsubscribe = null;
+    this.indexRemovedUnsubscribe?.();
+    this.indexRemovedUnsubscribe = null;
+    if (this.remoteEnsureRetryTimer !== null) {
+      clearTimeout(this.remoteEnsureRetryTimer);
+      this.remoteEnsureRetryTimer = null;
+    }
+    this.pendingRemoteSubsetEnsures.clear();
+    this.activeSubsets.clear();
+    this.queuedHydrationTransactions.length = 0;
+    this.queuedTxCommitted.length = 0;
+    this.clearSyncControls();
+  }
+  withInternalApply(task) {
+    this.internalApplyDepth++;
+    try {
+      task();
+    } finally {
+      this.internalApplyDepth--;
+    }
+  }
+  getRequiredIndexSignatures() {
+    if (!this.collection) {
+      return [];
+    }
+    return this.collection.getIndexMetadata().map((metadata) => metadata.signature);
+  }
+  loadSubsetRowsUnsafe(options) {
+    return this.persistence.adapter.loadSubset(this.collectionId, options, {
+      requiredIndexSignatures: this.getRequiredIndexSignatures()
+    });
+  }
+  async scanPersistedRowsUnsafe(options) {
+    if (!this.persistence.adapter.scanRows) {
+      return [];
+    }
+    return this.persistence.adapter.scanRows(this.collectionId, options);
+  }
+  async scanPersistedRows(options) {
+    return this.applyMutex.run(() => this.scanPersistedRowsUnsafe(options));
+  }
+  async hydrateSubsetUnsafe(options, config) {
+    this.isHydrating = true;
+    try {
+      const rows = await this.loadSubsetRowsUnsafe(options);
+      this.applyRowsToCollection(rows);
+    } finally {
+      this.isHydrating = false;
+    }
+    await this.flushQueuedHydrationTransactionsUnsafe();
+    await this.flushQueuedTxCommittedUnsafe();
+    if (config.requestRemoteEnsure) {
+      this.queueRemoteSubsetEnsure(options);
+    }
+  }
+  applyRowsToCollection(rows) {
+    if (!this.syncControls.begin || !this.syncControls.write || !this.syncControls.commit) {
+      return;
+    }
+    this.withInternalApply(() => {
+      this.syncControls.begin?.({ immediate: true });
+      for (const row of rows) {
+        this.syncControls.write?.({
+          type: `update`,
+          value: row.value,
+          metadata: row.metadata
+        });
+      }
+      this.syncControls.commit?.();
+    });
+  }
+  replaceCollectionSnapshot(rows, collectionMetadata) {
+    if (!this.syncControls.begin || !this.syncControls.write || !this.syncControls.commit || !this.syncControls.metadata) {
+      return;
+    }
+    const nextMetadata = new Map(
+      collectionMetadata.map(({ key, value }) => [key, value])
+    );
+    const currentKeys = this.syncControls.metadata.collection.list().map(({ key }) => key);
+    this.withInternalApply(() => {
+      this.syncControls.begin?.({ immediate: true });
+      this.syncControls.truncate?.();
+      for (const row of rows) {
+        this.syncControls.write?.({
+          type: `update`,
+          value: row.value,
+          metadata: row.metadata
+        });
+      }
+      currentKeys.forEach((key) => {
+        if (!nextMetadata.has(key)) {
+          this.syncControls.metadata?.collection.delete(key);
+        }
+      });
+      nextMetadata.forEach((value, key) => {
+        this.syncControls.metadata?.collection.set(key, value);
+      });
+      this.syncControls.commit?.();
+    });
+  }
+  async flushQueuedHydrationTransactionsUnsafe() {
+    while (this.queuedHydrationTransactions.length > 0) {
+      const transaction = this.queuedHydrationTransactions.shift();
+      if (!transaction) {
+        continue;
+      }
+      await this.applyBufferedSyncTransactionUnsafe(transaction);
+    }
+  }
+  async applyBufferedSyncTransactionUnsafe(transaction) {
+    if (!this.syncControls.begin || !this.syncControls.write || !this.syncControls.commit) {
+      return;
+    }
+    const applyToCollection = () => {
+      this.syncControls.begin?.();
+      if (transaction.truncate) {
+        this.syncControls.truncate?.();
+      }
+      for (const operation of transaction.operations) {
+        if (operation.type === `delete`) {
+          this.syncControls.write?.({
+            type: `delete`,
+            key: operation.key
+          });
+        } else {
+          this.syncControls.write?.({
+            type: `update`,
+            value: operation.value,
+            metadata: operation.metadata
+          });
+        }
+      }
+      for (const [key, metadataWrite] of transaction.rowMetadataWrites) {
+        if (metadataWrite.type === `delete`) {
+          this.syncControls.metadata?.row.delete(key);
+        } else {
+          this.syncControls.metadata?.row.set(key, metadataWrite.value);
+        }
+      }
+      for (const [key, metadataWrite] of transaction.collectionMetadataWrites) {
+        if (metadataWrite.type === `delete`) {
+          this.syncControls.metadata?.collection.delete(key);
+        } else {
+          this.syncControls.metadata?.collection.set(key, metadataWrite.value);
+        }
+      }
+      this.syncControls.commit?.();
+    };
+    if (transaction.internal) {
+      this.withInternalApply(applyToCollection);
+      return;
+    }
+    applyToCollection();
+    await this.persistAndBroadcastExternalSyncTransactionUnsafe(transaction);
+  }
+  async persistAndBroadcastExternalSyncTransactionUnsafe(transaction) {
+    if (transaction.internal) {
+      return;
+    }
+    const streamPosition = this.nextLocalStreamPosition();
+    if (!transaction.truncate && transaction.operations.length === 0 && transaction.rowMetadataWrites.size === 0 && transaction.collectionMetadataWrites.size === 0) {
+      this.publishTxCommittedEvent(
+        this.createTxCommittedPayload({
+          term: streamPosition.term,
+          seq: streamPosition.seq,
+          txId: crypto.randomUUID(),
+          latestRowVersion: streamPosition.rowVersion,
+          changedRows: [],
+          deletedKeys: [],
+          requiresFullReload: true
+        })
+      );
+      return;
+    }
+    const tx = this.createPersistedTxFromOperations(transaction, streamPosition);
+    await this.persistence.adapter.applyCommittedTx(this.collectionId, tx);
+    this.publishTxCommittedEvent(
+      this.createTxCommittedPayload({
+        term: tx.term,
+        seq: tx.seq,
+        txId: tx.txId,
+        latestRowVersion: tx.rowVersion,
+        requiresFullReload: transaction.truncate,
+        changedRows: transaction.operations.filter((operation) => operation.type === `update`).map((operation) => ({ key: operation.key, value: operation.value })),
+        deletedKeys: transaction.operations.filter((operation) => operation.type === `delete`).map((operation) => operation.key),
+        rowMetadataMutations: tx.rowMetadataMutations,
+        collectionMetadataMutations: tx.collectionMetadataMutations
+      })
+    );
+  }
+  createPersistedTxFromOperations(transaction, streamPosition) {
+    return {
+      txId: crypto.randomUUID(),
+      term: streamPosition.term,
+      seq: streamPosition.seq,
+      rowVersion: streamPosition.rowVersion,
+      truncate: transaction.truncate,
+      mutations: transaction.operations.map(
+        (operation) => operation.type === `update` ? {
+          type: `update`,
+          key: operation.key,
+          value: operation.value
+        } : {
+          type: `delete`,
+          key: operation.key,
+          value: operation.value
+        }
+      ),
+      rowMetadataMutations: Array.from(
+        transaction.rowMetadataWrites.entries()
+      ).map(
+        ([key, metadataWrite]) => metadataWrite.type === `delete` ? { type: `delete`, key } : { type: `set`, key, value: metadataWrite.value }
+      ),
+      collectionMetadataMutations: Array.from(
+        transaction.collectionMetadataWrites.entries()
+      ).map(
+        ([key, metadataWrite]) => metadataWrite.type === `delete` ? { type: `delete`, key } : { type: `set`, key, value: metadataWrite.value }
+      )
+    };
+  }
+  createPersistedTxFromMutations(mutations, streamPosition) {
+    return {
+      txId: crypto.randomUUID(),
+      term: streamPosition.term,
+      seq: streamPosition.seq,
+      rowVersion: streamPosition.rowVersion,
+      mutations: mutations.map((mutation) => {
+        if (mutation.type === `delete`) {
+          return {
+            type: `delete`,
+            key: mutation.key,
+            value: mutation.original
+          };
+        }
+        if (mutation.type === `insert`) {
+          return {
+            type: `insert`,
+            key: mutation.key,
+            value: mutation.modified
+          };
+        }
+        return {
+          type: `update`,
+          key: mutation.key,
+          value: mutation.modified
+        };
+      })
+    };
+  }
+  confirmMutationsSyncUnsafe(mutations) {
+    if (!this.syncControls.begin || !this.syncControls.write || !this.syncControls.commit) {
+      return;
+    }
+    this.withInternalApply(() => {
+      this.syncControls.begin?.({ immediate: true });
+      for (const mutation of mutations) {
+        if (mutation.type === `delete`) {
+          this.syncControls.write?.({
+            type: `delete`,
+            key: mutation.key
+          });
+        } else {
+          this.syncControls.write?.({
+            type: `update`,
+            value: mutation.modified
+          });
+        }
+      }
+      this.syncControls.commit?.();
+    });
+  }
+  filterMutationsForCollection(mutations) {
+    const collection = this.collection;
+    return mutations.filter((mutation) => {
+      if (collection) {
+        return mutation.collection === collection;
+      }
+      return mutation.collection.id === this.collectionId;
+    });
+  }
+  async persistCollectionMutationsUnsafe(mutations) {
+    if (this.persistence.coordinator.requestApplyLocalMutations) {
+      const envelopeMutations = mutations.map(
+        (mutation) => toPersistedMutationEnvelope(
+          mutation
+        )
+      );
+      const response = await this.persistence.coordinator.requestApplyLocalMutations(
+        this.collectionId,
+        envelopeMutations
+      );
+      if (!response.ok) {
+        throw new Error(
+          `failed to apply local mutations through coordinator: ${response.error}`
+        );
+      }
+      this.observeStreamPosition(
+        response.term,
+        response.seq,
+        response.latestRowVersion
+      );
+      const uniqueAcceptedMutationIds = Array.from(
+        new Set(response.acceptedMutationIds)
+      );
+      const submittedMutationIds = new Set(
+        mutations.map((mutation) => mutation.mutationId)
+      );
+      const hasUnknownAcceptedMutationId = uniqueAcceptedMutationIds.some(
+        (mutationId) => !submittedMutationIds.has(mutationId)
+      );
+      if (hasUnknownAcceptedMutationId) {
+        throw new Error(
+          `persistence coordinator returned unknown mutation ids in applyLocalMutations response`
+        );
+      }
+      return uniqueAcceptedMutationIds;
+    }
+    const streamPosition = this.nextLocalStreamPosition();
+    const tx = this.createPersistedTxFromMutations(mutations, streamPosition);
+    await this.persistence.adapter.applyCommittedTx(this.collectionId, tx);
+    this.publishTxCommittedEvent(
+      this.createTxCommittedPayload({
+        term: tx.term,
+        seq: tx.seq,
+        txId: tx.txId,
+        latestRowVersion: tx.rowVersion,
+        changedRows: mutations.filter((mutation) => mutation.type !== `delete`).map((mutation) => ({
+          key: mutation.key,
+          value: mutation.modified
+        })),
+        deletedKeys: mutations.filter((mutation) => mutation.type === `delete`).map((mutation) => mutation.key),
+        rowMetadataMutations: tx.rowMetadataMutations,
+        collectionMetadataMutations: tx.collectionMetadataMutations
+      })
+    );
+    return mutations.map((mutation) => mutation.mutationId);
+  }
+  createTxCommittedPayload(args) {
+    const rowMetadataMutations = args.rowMetadataMutations ?? [];
+    const collectionMetadataMutations = args.collectionMetadataMutations ?? [];
+    const requiresFullReload = args.requiresFullReload === true || args.changedRows.length + args.deletedKeys.length + rowMetadataMutations.length + collectionMetadataMutations.length > TARGETED_INVALIDATION_KEY_LIMIT;
+    if (requiresFullReload) {
+      return {
+        type: `tx:committed`,
+        term: args.term,
+        seq: args.seq,
+        txId: args.txId,
+        latestRowVersion: args.latestRowVersion,
+        requiresFullReload: true
+      };
+    }
+    return {
+      type: `tx:committed`,
+      term: args.term,
+      seq: args.seq,
+      txId: args.txId,
+      latestRowVersion: args.latestRowVersion,
+      requiresFullReload: false,
+      changedRows: args.changedRows,
+      deletedKeys: args.deletedKeys,
+      rowMetadataMutations,
+      collectionMetadataMutations
+    };
+  }
+  publishTxCommittedEvent(txCommitted) {
+    this.observeStreamPosition(
+      txCommitted.term,
+      txCommitted.seq,
+      txCommitted.latestRowVersion
+    );
+    const envelope = {
+      v: 1,
+      dbName: this.dbName,
+      collectionId: this.collectionId,
+      senderId: this.persistence.coordinator.getNodeId(),
+      ts: Date.now(),
+      payload: txCommitted
+    };
+    this.persistence.coordinator.publish(this.collectionId, envelope);
+  }
+  observeStreamPosition(term, seq, rowVersion) {
+    if (term > this.latestTerm || term === this.latestTerm && seq > this.latestSeq) {
+      this.latestTerm = term;
+      this.latestSeq = seq;
+    }
+    if (rowVersion > this.latestRowVersion) {
+      this.latestRowVersion = rowVersion;
+    }
+    if (term > this.localTerm) {
+      this.localTerm = term;
+      this.localSeq = seq;
+    } else if (term === this.localTerm && seq > this.localSeq) {
+      this.localSeq = seq;
+    }
+    if (rowVersion > this.localRowVersion) {
+      this.localRowVersion = rowVersion;
+    }
+  }
+  nextLocalStreamPosition() {
+    this.localTerm = Math.max(this.localTerm, this.latestTerm || 1);
+    this.localSeq = Math.max(this.localSeq, this.latestSeq) + 1;
+    this.localRowVersion = Math.max(this.localRowVersion, this.latestRowVersion) + 1;
+    return {
+      term: this.localTerm,
+      seq: this.localSeq,
+      rowVersion: this.localRowVersion
+    };
+  }
+  getSubsetKey(options) {
+    const subscription = options.subscription;
+    if (subscription && typeof subscription === `object`) {
+      const existingId = this.subscriptionIds.get(subscription);
+      if (existingId) {
+        return existingId;
+      }
+      this.nextSubscriptionId++;
+      const id = `sub:${this.nextSubscriptionId}`;
+      this.subscriptionIds.set(subscription, id);
+      return id;
+    }
+    return `opts:${stableSerialize(normalizeSubsetOptionsForKey(options))}`;
+  }
+  queueRemoteSubsetEnsure(options) {
+    if (this.mode !== `sync-present` || !this.persistence.coordinator.requestEnsureRemoteSubset) {
+      return;
+    }
+    this.pendingRemoteSubsetEnsures.set(this.getSubsetKey(options), options);
+    void this.flushPendingRemoteSubsetEnsures();
+  }
+  scheduleRemoteEnsureRetry() {
+    if (this.mode !== `sync-present` || !this.persistence.coordinator.requestEnsureRemoteSubset) {
+      return;
+    }
+    if (this.pendingRemoteSubsetEnsures.size === 0 || this.remoteEnsureRetryTimer !== null) {
+      return;
+    }
+    this.remoteEnsureRetryTimer = setTimeout(() => {
+      this.remoteEnsureRetryTimer = null;
+      void this.flushPendingRemoteSubsetEnsures();
+    }, REMOTE_ENSURE_RETRY_DELAY_MS);
+  }
+  async flushPendingRemoteSubsetEnsures() {
+    if (this.mode !== `sync-present` || !this.persistence.coordinator.requestEnsureRemoteSubset) {
+      return;
+    }
+    if (this.remoteEnsureRetryTimer !== null) {
+      clearTimeout(this.remoteEnsureRetryTimer);
+      this.remoteEnsureRetryTimer = null;
+    }
+    for (const [subsetKey, options] of this.pendingRemoteSubsetEnsures) {
+      try {
+        await this.persistence.coordinator.requestEnsureRemoteSubset(
+          this.collectionId,
+          options
+        );
+        this.pendingRemoteSubsetEnsures.delete(subsetKey);
+      } catch (error) {
+        console.warn(`Failed to ensure remote subset:`, error);
+      }
+    }
+    this.scheduleRemoteEnsureRetry();
+  }
+  attachCoordinatorSubscription() {
+    if (this.coordinatorUnsubscribe) {
+      return;
+    }
+    this.coordinatorUnsubscribe = this.persistence.coordinator.subscribe(
+      this.collectionId,
+      (message) => {
+        this.onCoordinatorMessage(message);
+      }
+    );
+  }
+  onCoordinatorMessage(message) {
+    if (message.collectionId !== this.collectionId) {
+      return;
+    }
+    const { payload } = message;
+    const isSelf = message.senderId === this.persistence.coordinator.getNodeId();
+    if (isTxCommittedPayload(payload)) {
+      if (this.isHydrating) {
+        this.queuedTxCommitted.push(payload);
+        return;
+      }
+      void this.applyMutex.run(() => this.processCommittedTxUnsafe(payload)).catch((error) => {
+        console.warn(`Failed to process tx:committed message:`, error);
+      });
+      return;
+    }
+    if (isSelf) {
+      return;
+    }
+    if (isCollectionResetPayload(payload)) {
+      void this.applyMutex.run(() => this.truncateAndReloadUnsafe()).catch((error) => {
+        console.warn(`Failed to process collection reset message:`, error);
+      });
+    }
+  }
+  async flushQueuedTxCommittedUnsafe() {
+    while (this.queuedTxCommitted.length > 0) {
+      const queued = this.queuedTxCommitted.shift();
+      if (!queued) {
+        continue;
+      }
+      await this.processCommittedTxUnsafe(queued);
+    }
+  }
+  async processCommittedTxUnsafe(txCommitted) {
+    if (txCommitted.term < this.latestTerm) {
+      return;
+    }
+    if (txCommitted.term === this.latestTerm && txCommitted.seq <= this.latestSeq) {
+      return;
+    }
+    const hasGapInCurrentTerm = txCommitted.term === this.latestTerm && txCommitted.seq > this.latestSeq + 1;
+    const hasGapAcrossTerms = txCommitted.term > this.latestTerm && txCommitted.seq > 1;
+    const hasGap = hasGapInCurrentTerm || hasGapAcrossTerms;
+    if (hasGap) {
+      await this.recoverFromSeqGapUnsafe();
+      if (txCommitted.term < this.latestTerm || txCommitted.term === this.latestTerm && txCommitted.seq <= this.latestSeq) {
+        return;
+      }
+    }
+    this.observeStreamPosition(
+      txCommitted.term,
+      txCommitted.seq,
+      txCommitted.latestRowVersion
+    );
+    await this.invalidateFromCommittedTxUnsafe(txCommitted);
+  }
+  async recoverFromSeqGapUnsafe() {
+    if (this.persistence.coordinator.pullSince && this.latestRowVersion >= 0) {
+      try {
+        const pullResponse = await this.persistence.coordinator.pullSince(
+          this.collectionId,
+          this.latestRowVersion
+        );
+        if (pullResponse.ok) {
+          this.observeStreamPosition(
+            pullResponse.latestTerm,
+            pullResponse.latestSeq,
+            pullResponse.latestRowVersion
+          );
+          if (pullResponse.requiresFullReload || !pullResponse.deltas) {
+            await this.reloadActiveSubsetsUnsafe();
+            return;
+          }
+          for (const delta of pullResponse.deltas) {
+            await this.invalidateFromCommittedTxUnsafe({
+              type: `tx:committed`,
+              term: pullResponse.latestTerm,
+              seq: pullResponse.latestSeq,
+              txId: delta.txId,
+              latestRowVersion: delta.latestRowVersion,
+              requiresFullReload: false,
+              changedRows: delta.changedRows,
+              deletedKeys: delta.deletedKeys,
+              rowMetadataMutations: delta.rowMetadataMutations,
+              collectionMetadataMutations: delta.collectionMetadataMutations
+            });
+          }
+          return;
+        }
+      } catch (error) {
+        console.warn(`Failed pullSince recovery attempt:`, error);
+      }
+    }
+    await this.truncateAndReloadUnsafe();
+    if (this.mode === `sync-present`) {
+      for (const options of this.activeSubsets.values()) {
+        this.queueRemoteSubsetEnsure(options);
+      }
+    }
+  }
+  async truncateAndReloadUnsafe() {
+    if (this.syncControls.begin && this.syncControls.commit) {
+      this.withInternalApply(() => {
+        this.syncControls.begin?.({ immediate: true });
+        this.syncControls.truncate?.();
+        this.syncControls.commit?.();
+      });
+    }
+    await this.reloadActiveSubsetsUnsafe();
+  }
+  async invalidateFromCommittedTxUnsafe(txCommitted) {
+    if (txCommitted.requiresFullReload) {
+      await this.reloadActiveSubsetsUnsafe();
+      return;
+    }
+    const changedKeyCount = txCommitted.changedRows.length + txCommitted.deletedKeys.length;
+    if (changedKeyCount > TARGETED_INVALIDATION_KEY_LIMIT) {
+      await this.reloadActiveSubsetsUnsafe();
+      return;
+    }
+    const hasPaginatedSubset = Array.from(this.activeSubsets.values()).some(
+      (opt) => opt.limit != null || opt.offset != null || opt.cursor != null
+    );
+    if (!hasPaginatedSubset || changedKeyCount === 0) {
+      await this.applyTargetedInvalidationUnsafe(txCommitted);
+      return;
+    }
+    await this.reloadActiveSubsetsUnsafe();
+  }
+  async applyTargetedInvalidationUnsafe(txCommitted) {
+    const subsetEvaluators = Array.from(this.activeSubsets.values()).map(
+      (opt) => opt.where ? db.compileSingleRowExpression(opt.where) : null
+    );
+    this.withInternalApply(() => {
+      this.syncControls.begin?.({ immediate: true });
+      for (const {
+        key: changedKey,
+        value: newValue
+      } of txCommitted.changedRows) {
+        const matchesAnySubset = subsetEvaluators.some((evaluator) => {
+          if (!evaluator) return true;
+          return db.toBooleanPredicate(evaluator(newValue));
+        });
+        if (matchesAnySubset) {
+          this.syncControls.write?.({ type: `update`, value: newValue });
+        } else if (this.collection?.get(changedKey) !== void 0) {
+          this.syncControls.write?.({ type: `delete`, key: changedKey });
+        }
+      }
+      for (const deletedKey of txCommitted.deletedKeys) {
+        this.syncControls.write?.({ type: `delete`, key: deletedKey });
+      }
+      txCommitted.rowMetadataMutations?.forEach((mutation) => {
+        if (mutation.type === `delete`) {
+          this.syncControls.metadata?.row.delete(mutation.key);
+        } else {
+          this.syncControls.metadata?.row.set(
+            mutation.key,
+            mutation.value
+          );
+        }
+      });
+      txCommitted.collectionMetadataMutations?.forEach((mutation) => {
+        if (mutation.type === `delete`) {
+          this.syncControls.metadata?.collection.delete(mutation.key);
+        } else {
+          this.syncControls.metadata?.collection.set(
+            mutation.key,
+            mutation.value
+          );
+        }
+      });
+      this.syncControls.commit?.();
+    });
+  }
+  async reloadActiveSubsetsUnsafe() {
+    const activeSubsetOptions = this.activeSubsets.size > 0 ? Array.from(this.activeSubsets.values()) : [{}];
+    this.isHydrating = true;
+    try {
+      const mergedRows = /* @__PURE__ */ new Map();
+      const collectionMetadata = await this.loadCollectionMetadataSnapshot();
+      for (const options of activeSubsetOptions) {
+        const subsetRows = await this.loadSubsetRowsUnsafe(options);
+        for (const row of subsetRows) {
+          mergedRows.set(row.key, {
+            value: row.value,
+            metadata: row.metadata
+          });
+        }
+      }
+      this.replaceCollectionSnapshot(
+        Array.from(mergedRows.entries()).map(([key, row]) => ({
+          key,
+          value: row.value,
+          metadata: row.metadata
+        })),
+        collectionMetadata
+      );
+    } finally {
+      this.isHydrating = false;
+    }
+    await this.flushQueuedHydrationTransactionsUnsafe();
+    await this.flushQueuedTxCommittedUnsafe();
+  }
+  attachIndexLifecycleListeners() {
+    if (!this.collection || this.indexAddedUnsubscribe || this.indexRemovedUnsubscribe) {
+      return;
+    }
+    this.indexAddedUnsubscribe = this.collection.on(`index:added`, (event) => {
+      void this.ensurePersistedIndex(event.index);
+    });
+    this.indexRemovedUnsubscribe = this.collection.on(
+      `index:removed`,
+      (event) => {
+        void this.markIndexRemoved(event.index);
+      }
+    );
+  }
+  async bootstrapPersistedIndexes(indexMetadataSnapshot) {
+    const collection = this.collection;
+    if (!collection && !indexMetadataSnapshot) {
+      return;
+    }
+    const indexMetadata = indexMetadataSnapshot ?? collection?.getIndexMetadata() ?? [];
+    for (const metadata of indexMetadata) {
+      await this.ensurePersistedIndex(metadata);
+    }
+  }
+  buildPersistedIndexSpec(index) {
+    return {
+      expressionSql: [stableSerialize(index.expression)],
+      metadata: {
+        name: index.name ?? null,
+        resolver: toStableSerializable(index.resolver),
+        options: toStableSerializable(index.options)
+      }
+    };
+  }
+  async ensurePersistedIndex(indexMetadata) {
+    const spec = this.buildPersistedIndexSpec(indexMetadata);
+    try {
+      await this.persistence.adapter.ensureIndex(
+        this.collectionId,
+        indexMetadata.signature,
+        spec
+      );
+    } catch (error) {
+      console.warn(`Failed to ensure persisted index in adapter:`, error);
+    }
+    try {
+      await this.persistence.coordinator.requestEnsurePersistedIndex(
+        this.collectionId,
+        indexMetadata.signature,
+        spec
+      );
+    } catch (error) {
+      console.warn(
+        `Failed to ensure persisted index through coordinator:`,
+        error
+      );
+    }
+  }
+  async markIndexRemoved(indexMetadata) {
+    if (!this.persistence.adapter.markIndexRemoved) {
+      return;
+    }
+    try {
+      await this.persistence.adapter.markIndexRemoved(
+        this.collectionId,
+        indexMetadata.signature
+      );
+    } catch (error) {
+      console.warn(`Failed to mark persisted index removed:`, error);
+    }
+  }
+}
+function createWrappedSyncConfig(sourceSyncConfig, runtime) {
+  return {
+    ...sourceSyncConfig,
+    sync: (params) => {
+      const transactionStack = [];
+      const getOpenTransaction = () => transactionStack[transactionStack.length - 1];
+      let fullStartPromise = null;
+      const cancelledLoadKeys = /* @__PURE__ */ new Set();
+      const loadSubscriptionIds = /* @__PURE__ */ new WeakMap();
+      let nextLoadSubscriptionId = 0;
+      const getLoadKey = (options) => {
+        const subscription = options.subscription;
+        if (subscription && typeof subscription === `object`) {
+          const existingId = loadSubscriptionIds.get(subscription);
+          if (existingId) {
+            return `sub:${existingId}`;
+          }
+          nextLoadSubscriptionId++;
+          const nextId = String(nextLoadSubscriptionId);
+          loadSubscriptionIds.set(subscription, nextId);
+          return `sub:${nextId}`;
+        }
+        return `opts:${stableSerialize(normalizeSubsetOptionsForKey(options))}`;
+      };
+      runtime.setSyncControls({
+        begin: params.begin,
+        write: params.write,
+        commit: params.commit,
+        truncate: params.truncate,
+        metadata: params.metadata ?? null
+      });
+      runtime.setCollection(
+        params.collection
+      );
+      const wrappedParams = {
+        ...params,
+        markReady: () => {
+          void (fullStartPromise ?? runtime.ensureStarted()).then(() => {
+            params.markReady();
+          }).catch((error) => {
+            console.warn(
+              `Failed persisted sync startup before markReady:`,
+              error
+            );
+            params.markReady();
+          });
+        },
+        begin: (options) => {
+          const transaction = {
+            operations: [],
+            rowMetadataWrites: /* @__PURE__ */ new Map(),
+            collectionMetadataWrites: /* @__PURE__ */ new Map(),
+            truncate: false,
+            internal: runtime.isApplyingInternally(),
+            queuedBecauseHydrating: !runtime.isApplyingInternally() && runtime.isHydratingNow()
+          };
+          transactionStack.push(transaction);
+          if (!transaction.queuedBecauseHydrating) {
+            params.begin(options);
+          }
+        },
+        write: (message) => {
+          const normalization = runtime.normalizeSyncWriteMessage(message);
+          const openTransaction = getOpenTransaction();
+          if (!openTransaction) {
+            params.write(normalization.forwardMessage);
+            return;
+          }
+          openTransaction.operations.push(normalization.operation);
+          if (normalization.operation.type === `delete`) {
+            openTransaction.rowMetadataWrites.set(normalization.operation.key, {
+              type: `delete`
+            });
+          } else if (message.type === `insert` && normalization.operation.metadata === void 0) {
+            openTransaction.rowMetadataWrites.set(normalization.operation.key, {
+              type: `delete`
+            });
+          } else if (normalization.operation.metadata !== void 0) {
+            openTransaction.rowMetadataWrites.set(normalization.operation.key, {
+              type: `set`,
+              value: normalization.operation.metadata
+            });
+          }
+          if (!openTransaction.queuedBecauseHydrating) {
+            params.write(normalization.forwardMessage);
+          }
+        },
+        metadata: params.metadata ? {
+          row: {
+            get: (key) => {
+              const openTransaction = getOpenTransaction();
+              const pendingWrite = openTransaction?.rowMetadataWrites.get(key);
+              if (pendingWrite) {
+                return pendingWrite.type === `delete` ? void 0 : pendingWrite.value;
+              }
+              if (openTransaction?.truncate) {
+                return void 0;
+              }
+              return params.metadata.row.get(key);
+            },
+            scanPersisted: (options) => runtime.scanPersistedRows(options),
+            set: (key, value) => {
+              const openTransaction = getOpenTransaction();
+              if (!openTransaction) {
+                throw new errors.InvalidPersistedCollectionConfigError(
+                  `metadata.row.set must be called within an open sync transaction`
+                );
+              }
+              openTransaction.rowMetadataWrites.set(key, {
+                type: `set`,
+                value
+              });
+              if (!openTransaction.queuedBecauseHydrating) {
+                params.metadata.row.set(key, value);
+              }
+            },
+            delete: (key) => {
+              const openTransaction = getOpenTransaction();
+              if (!openTransaction) {
+                throw new errors.InvalidPersistedCollectionConfigError(
+                  `metadata.row.delete must be called within an open sync transaction`
+                );
+              }
+              openTransaction.rowMetadataWrites.set(key, {
+                type: `delete`
+              });
+              if (!openTransaction.queuedBecauseHydrating) {
+                params.metadata.row.delete(key);
+              }
+            }
+          },
+          collection: {
+            get: (key) => {
+              const openTransaction = getOpenTransaction();
+              const pendingWrite = openTransaction?.collectionMetadataWrites.get(key);
+              if (pendingWrite) {
+                return pendingWrite.type === `delete` ? void 0 : pendingWrite.value;
+              }
+              return params.metadata.collection.get(key);
+            },
+            set: (key, value) => {
+              const openTransaction = getOpenTransaction();
+              if (!openTransaction) {
+                throw new errors.InvalidPersistedCollectionConfigError(
+                  `metadata.collection.set must be called within an open sync transaction`
+                );
+              }
+              openTransaction.collectionMetadataWrites.set(key, {
+                type: `set`,
+                value
+              });
+              if (!openTransaction.queuedBecauseHydrating) {
+                params.metadata.collection.set(key, value);
+              }
+            },
+            delete: (key) => {
+              const openTransaction = getOpenTransaction();
+              if (!openTransaction) {
+                throw new errors.InvalidPersistedCollectionConfigError(
+                  `metadata.collection.delete must be called within an open sync transaction`
+                );
+              }
+              openTransaction.collectionMetadataWrites.set(key, {
+                type: `delete`
+              });
+              if (!openTransaction.queuedBecauseHydrating) {
+                params.metadata.collection.delete(key);
+              }
+            },
+            list: (prefix) => {
+              const merged = new Map(
+                params.metadata.collection.list().map(({ key, value }) => [key, value])
+              );
+              const openTransaction = getOpenTransaction();
+              if (openTransaction) {
+                for (const [
+                  key,
+                  metadataWrite
+                ] of openTransaction.collectionMetadataWrites) {
+                  if (metadataWrite.type === `delete`) {
+                    merged.delete(key);
+                  } else {
+                    merged.set(key, metadataWrite.value);
+                  }
+                }
+              }
+              return Array.from(merged.entries()).filter(([key]) => prefix ? key.startsWith(prefix) : true).map(([key, value]) => ({
+                key,
+                value
+              }));
+            }
+          }
+        } : void 0,
+        truncate: () => {
+          const openTransaction = getOpenTransaction();
+          if (!openTransaction) {
+            params.truncate();
+            return;
+          }
+          openTransaction.operations = [];
+          openTransaction.rowMetadataWrites.clear();
+          openTransaction.truncate = true;
+          if (!openTransaction.queuedBecauseHydrating) {
+            params.truncate();
+          }
+        },
+        commit: () => {
+          const openTransaction = transactionStack.pop();
+          if (!openTransaction) {
+            params.commit();
+            return;
+          }
+          if (openTransaction.queuedBecauseHydrating) {
+            runtime.queueHydrationBufferedTransaction({
+              operations: openTransaction.operations,
+              rowMetadataWrites: openTransaction.rowMetadataWrites,
+              collectionMetadataWrites: openTransaction.collectionMetadataWrites,
+              truncate: openTransaction.truncate,
+              internal: openTransaction.internal
+            });
+            return;
+          }
+          params.commit();
+          if (!openTransaction.internal) {
+            void runtime.persistAndBroadcastExternalSyncTransaction({
+              operations: openTransaction.operations,
+              rowMetadataWrites: openTransaction.rowMetadataWrites,
+              collectionMetadataWrites: openTransaction.collectionMetadataWrites,
+              truncate: openTransaction.truncate,
+              internal: false
+            }).catch((error) => {
+              console.warn(
+                `Failed to persist wrapped sync transaction:`,
+                error
+              );
+            });
+          }
+        }
+      };
+      let sourceResult = {};
+      const startupState = { cleanedUp: false };
+      fullStartPromise = runtime.ensureStarted();
+      const sourceResultPromise = (async () => {
+        await runtime.ensureStartupMetadataLoaded();
+        if (startupState.cleanedUp) {
+          return sourceResult;
+        }
+        sourceResult = normalizeSyncFnResult(
+          sourceSyncConfig.sync(wrappedParams)
+        );
+        return sourceResult;
+      })();
+      return {
+        cleanup: () => {
+          startupState.cleanedUp = true;
+          sourceResult.cleanup?.();
+          runtime.cleanup();
+          runtime.clearSyncControls();
+        },
+        loadSubset: async (options) => {
+          const loadKey = getLoadKey(options);
+          cancelledLoadKeys.delete(loadKey);
+          await fullStartPromise;
+          const resolvedSourceResult = await sourceResultPromise;
+          if (startupState.cleanedUp || cancelledLoadKeys.has(loadKey)) {
+            return;
+          }
+          await runtime.loadSubset(options, resolvedSourceResult.loadSubset);
+        },
+        unloadSubset: (options) => {
+          cancelledLoadKeys.add(getLoadKey(options));
+          runtime.unloadSubset(options, sourceResult.unloadSubset);
+        }
+      };
+    }
+  };
+}
+function createLoopbackSyncConfig(runtime) {
+  return {
+    sync: (params) => {
+      runtime.setSyncControls({
+        begin: params.begin,
+        write: params.write,
+        commit: params.commit,
+        truncate: params.truncate,
+        metadata: params.metadata ?? null
+      });
+      runtime.setCollection(
+        params.collection
+      );
+      void runtime.ensureStarted().then(() => {
+        params.markReady();
+      }).catch((error) => {
+        console.warn(`Failed persisted loopback startup:`, error);
+        params.markReady();
+      });
+      return {
+        cleanup: () => {
+          runtime.cleanup();
+          runtime.clearSyncControls();
+        },
+        loadSubset: (options) => runtime.loadSubset(options),
+        unloadSubset: (options) => runtime.unloadSubset(options)
+      };
+    },
+    getSyncMetadata: () => ({
+      source: `persisted-phase-2-loopback`
+    })
+  };
+}
+function persistedCollectionOptions(options) {
+  if (!isRecord(options.persistence)) {
+    throw new errors.InvalidPersistedCollectionConfigError(
+      `persistedCollectionOptions requires a persistence adapter`
+    );
+  }
+  if (hasOwnSyncKey(options)) {
+    if (!isValidSyncConfig(options.sync)) {
+      throw new errors.InvalidSyncConfigError(
+        `when the "sync" key is present it must provide a callable sync function`
+      );
+    }
+    const { schemaVersion: schemaVersion2, ...syncOptions } = options;
+    const collectionId2 = syncOptions.id ?? `persisted-collection:${crypto.randomUUID()}`;
+    const persistence2 = resolvePersistenceForCollection(
+      syncOptions.persistence,
+      {
+        collectionId: collectionId2,
+        mode: `sync-present`,
+        schemaVersion: schemaVersion2
+      }
+    );
+    const runtime2 = new PersistedCollectionRuntime(
+      `sync-present`,
+      collectionId2,
+      persistence2,
+      syncOptions.syncMode ?? `eager`,
+      collectionId2
+    );
+    return {
+      ...syncOptions,
+      id: collectionId2,
+      sync: createWrappedSyncConfig(syncOptions.sync, runtime2),
+      persistence: persistence2
+    };
+  }
+  const { schemaVersion, ...localOnlyOptions } = options;
+  const collectionId = localOnlyOptions.id ?? `persisted-collection:${crypto.randomUUID()}`;
+  const persistence = resolvePersistenceForCollection(
+    localOnlyOptions.persistence,
+    {
+      collectionId,
+      mode: `sync-absent`,
+      schemaVersion
+    }
+  );
+  const runtime = new PersistedCollectionRuntime(
+    `sync-absent`,
+    collectionId,
+    persistence,
+    localOnlyOptions.syncMode ?? `eager`,
+    localOnlyOptions.id ?? DEFAULT_DB_NAME
+  );
+  const wrappedOnInsert = async (params) => {
+    const handlerResult = localOnlyOptions.onInsert ? await localOnlyOptions.onInsert(
+      params
+    ) : void 0;
+    await runtime.persistAndConfirmCollectionMutations(
+      params.transaction.mutations
+    );
+    return handlerResult ?? {};
+  };
+  const wrappedOnUpdate = async (params) => {
+    const handlerResult = localOnlyOptions.onUpdate ? await localOnlyOptions.onUpdate(
+      params
+    ) : void 0;
+    await runtime.persistAndConfirmCollectionMutations(
+      params.transaction.mutations
+    );
+    return handlerResult ?? {};
+  };
+  const wrappedOnDelete = async (params) => {
+    const handlerResult = localOnlyOptions.onDelete ? await localOnlyOptions.onDelete(
+      params
+    ) : void 0;
+    await runtime.persistAndConfirmCollectionMutations(
+      params.transaction.mutations
+    );
+    return handlerResult ?? {};
+  };
+  const acceptMutations = async (transaction) => {
+    await runtime.acceptTransactionMutations(transaction);
+  };
+  const persistedUtils = {
+    acceptMutations,
+    getLeadershipState: () => runtime.getLeadershipState(),
+    forceReloadSubset: (subsetOptions) => runtime.forceReloadSubset(subsetOptions)
+  };
+  const mergedUtils = {
+    ...localOnlyOptions.utils ?? {},
+    ...persistedUtils
+  };
+  return {
+    ...localOnlyOptions,
+    id: collectionId,
+    persistence,
+    sync: createLoopbackSyncConfig(runtime),
+    onInsert: wrappedOnInsert,
+    onUpdate: wrappedOnUpdate,
+    onDelete: wrappedOnDelete,
+    utils: mergedUtils,
+    startSync: true,
+    gcTime: localOnlyOptions.gcTime ?? 0
+  };
+}
+function encodePersistedStorageKey(key) {
+  if (typeof key === `number`) {
+    if (!Number.isFinite(key)) {
+      throw new errors.InvalidPersistedStorageKeyError(key);
+    }
+    if (Object.is(key, -0)) {
+      return `n:-0`;
+    }
+    return `n:${key}`;
+  }
+  return `s:${key}`;
+}
+function decodePersistedStorageKey(encoded) {
+  if (encoded === `n:-0`) {
+    return -0;
+  }
+  if (encoded.startsWith(`n:`)) {
+    return Number(encoded.slice(2));
+  }
+  if (encoded.startsWith(`s:`)) {
+    return encoded.slice(2);
+  }
+  throw new errors.InvalidPersistedStorageKeyEncodingError(encoded);
+}
+const PERSISTED_TABLE_NAME_ALPHABET = `abcdefghijklmnopqrstuvwxyz234567`;
+function hashCollectionId(collectionId) {
+  let hash = 2166136261;
+  for (let index = 0; index < collectionId.length; index++) {
+    hash ^= collectionId.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function toBase32(input) {
+  if (input === 0) {
+    return PERSISTED_TABLE_NAME_ALPHABET.charAt(0);
+  }
+  let value = input >>> 0;
+  let output = ``;
+  while (value > 0) {
+    output = `${PERSISTED_TABLE_NAME_ALPHABET.charAt(value % 32)}${output}`;
+    value = Math.floor(value / 32);
+  }
+  return output;
+}
+function createPersistedTableName(collectionId, prefix = `c`) {
+  if (!collectionId) {
+    throw new errors.InvalidPersistedCollectionConfigError(
+      `collectionId is required to derive a persisted table name`
+    );
+  }
+  const hashPart = toBase32(hashCollectionId(collectionId));
+  const lengthPart = collectionId.length.toString(36);
+  return `${prefix}_${hashPart}_${lengthPart}`;
+}
+exports.SingleProcessCoordinator = SingleProcessCoordinator;
+exports.createPersistedTableName = createPersistedTableName;
+exports.decodePersistedStorageKey = decodePersistedStorageKey;
+exports.encodePersistedStorageKey = encodePersistedStorageKey;
+exports.persistedCollectionOptions = persistedCollectionOptions;
+exports.validatePersistedCollectionCoordinator = validatePersistedCollectionCoordinator;
+//# sourceMappingURL=persisted.cjs.map