@dynamic-labs-sdk/client 1.33.3 → 1.33.4

package/dist/services/resilientIndexedDbStore/utils/deleteRecord/index.d.ts

@@ -0,0 +1,2 @@
+export { deleteRecord } from './deleteRecord';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/deleteRecord/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/deleteRecord/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getBackoffDelay/getBackoffDelay.d.ts

@@ -0,0 +1,22 @@
+type GetBackoffDelayParams = {
+    /** How many attempts have already failed. */
+    attempt: number;
+};
+/**
+ * Exponential backoff between IndexedDB attempts, capped so a caller waiting
+ * on a read never sits through a multi-second gap.
+ *
+ * @example
+ * ```ts
+ * await waitForDelay({ delayMs: getBackoffDelay({ attempt: 3 }) });
+ * ```
+ *
+ * @param params.attempt - How many attempts have already failed.
+ * @returns The delay in milliseconds to wait before the next attempt.
+ * @see waitForDelay
+ * @see readStoredValue
+ * @notInstrumented
+ */
+export declare const getBackoffDelay: ({ attempt }: GetBackoffDelayParams) => number;
+export {};
+//# sourceMappingURL=getBackoffDelay.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getBackoffDelay/getBackoffDelay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBackoffDelay.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getBackoffDelay/getBackoffDelay.ts"],"names":[],"mappings":"AAEA,KAAK,qBAAqB,GAAG;IAC3B,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,gBAAiB,qBAAqB,KAAG,MAIpE,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getBackoffDelay/index.d.ts

@@ -0,0 +1,2 @@
+export { getBackoffDelay } from './getBackoffDelay';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getBackoffDelay/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getBackoffDelay/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getRecord/getRecord.d.ts

@@ -0,0 +1,32 @@
+type GetRecordParams = {
+    /** An open connection to the store's database. */
+    db: IDBDatabase;
+    /** Key of the record to read. */
+    key: string;
+    /** Name of the object store to read from. */
+    storeName: string;
+};
+/**
+ * Reads a single record from an object store.
+ *
+ * Values come back exactly as they were written, through structured clone, so
+ * types that cannot be serialized (such as a non-extractable `CryptoKey`)
+ * survive the round trip.
+ *
+ * @example
+ * ```ts
+ * const record = await getRecord<StoredKey>({ db, key: 'session', storeName: 'keys' });
+ * ```
+ *
+ * @param params.db - An open connection to the store's database.
+ * @param params.key - Key of the record to read.
+ * @param params.storeName - Name of the object store to read from.
+ * @returns The stored value, or undefined when the key has no record.
+ * @throws When IndexedDB rejects the read.
+ * @see withDatabase
+ * @see readStoredValue
+ * @notInstrumented
+ */
+export declare const getRecord: <TValue>({ db, key, storeName, }: GetRecordParams) => Promise<TValue | undefined>;
+export {};
+//# sourceMappingURL=getRecord.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getRecord/getRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRecord.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getRecord/getRecord.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,kDAAkD;IAClD,EAAE,EAAE,WAAW,CAAC;IAEhB,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IAEZ,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,2BAI7B,eAAe,KAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAQ3C,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getRecord/index.d.ts

@@ -0,0 +1,2 @@
+export { getRecord } from './getRecord';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getRecord/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getRecord/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getRecordKey/getRecordKey.d.ts

@@ -0,0 +1,27 @@
+type GetRecordKeyParams<TValue> = {
+    /** Property of a value that holds its key. */
+    keyPath: string;
+    /** The value to read the key from. */
+    value: TValue;
+};
+/**
+ * The key IndexedDB stores a value under, read from the value itself.
+ *
+ * A value whose key path holds no string has no key to be stored under, so the
+ * caller learns that before IndexedDB rejects the write.
+ *
+ * @example
+ * ```ts
+ * const key = getRecordKey({ keyPath: 'keyName', value: storedKey });
+ * ```
+ *
+ * @param params.keyPath - Property of a value that holds its key.
+ * @param params.value - The value to read the key from.
+ * @returns The key, or undefined when the key path holds no string.
+ * @see createResilientIndexedDbStore
+ * @see putRecord
+ * @notInstrumented
+ */
+export declare const getRecordKey: <TValue>({ keyPath, value, }: GetRecordKeyParams<TValue>) => string | undefined;
+export {};
+//# sourceMappingURL=getRecordKey.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getRecordKey/getRecordKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRecordKey.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getRecordKey/getRecordKey.ts"],"names":[],"mappings":"AAAA,KAAK,kBAAkB,CAAC,MAAM,IAAI;IAChC,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAEhB,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,uBAGhC,kBAAkB,CAAC,MAAM,CAAC,KAAG,MAAM,GAAG,SAcxC,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getRecordKey/index.d.ts

@@ -0,0 +1,2 @@
+export { getRecordKey } from './getRecordKey';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getRecordKey/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getRecordKey/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getTransactionError/getTransactionError.d.ts

@@ -0,0 +1,28 @@
+type GetTransactionErrorParams = {
+    /** The request that ran inside the transaction. */
+    request: IDBRequest;
+    /** The transaction that failed or was aborted. */
+    transaction: IDBTransaction;
+};
+/**
+ * The reason a write transaction did not commit.
+ *
+ * A transaction aborted by the browser rather than by a failing request, as
+ * happens when a connection closes mid-transaction, carries no error on either
+ * object, so the caller still gets something to log and retry on.
+ *
+ * @example
+ * ```ts
+ * transaction.onabort = () => reject(getTransactionError({ request, transaction }));
+ * ```
+ *
+ * @param params.request - The request that ran inside the transaction.
+ * @param params.transaction - The transaction that failed or was aborted.
+ * @returns The error to reject the write with.
+ * @see putRecord
+ * @see deleteRecord
+ * @notInstrumented
+ */
+export declare const getTransactionError: ({ request, transaction, }: GetTransactionErrorParams) => Error;
+export {};
+//# sourceMappingURL=getTransactionError.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getTransactionError/getTransactionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTransactionError.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getTransactionError/getTransactionError.ts"],"names":[],"mappings":"AAEA,KAAK,yBAAyB,GAAG;IAC/B,mDAAmD;IACnD,OAAO,EAAE,UAAU,CAAC;IAEpB,kDAAkD;IAClD,WAAW,EAAE,cAAc,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,8BAG7B,yBAAyB,KAAG,KAQ9B,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getTransactionError/index.d.ts

@@ -0,0 +1,2 @@
+export { getTransactionError } from './getTransactionError';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getTransactionError/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getTransactionError/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/isPermanentWriteError/index.d.ts

@@ -0,0 +1,2 @@
+export { isPermanentWriteError } from './isPermanentWriteError';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/isPermanentWriteError/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/isPermanentWriteError/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/isPermanentWriteError/isPermanentWriteError.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether IndexedDB rejected a write because of what it was asked to write,
+ * which tells a retrying caller to give the write up instead of repeating it
+ * for as long as the process lives.
+ *
+ * @example
+ * ```ts
+ * if (isPermanentWriteError(error)) {
+ *   logger?.debug('Dropping a mutation IndexedDB will never accept', error);
+ * }
+ * ```
+ *
+ * @param error - Whatever the write rejected with.
+ * @returns Whether repeating the write is pointless.
+ * @see createWorkQueue
+ * @see applyMutation
+ * @notInstrumented
+ */
+export declare const isPermanentWriteError: (error: unknown) => boolean;
+//# sourceMappingURL=isPermanentWriteError.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/isPermanentWriteError/isPermanentWriteError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPermanentWriteError.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/isPermanentWriteError/isPermanentWriteError.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,UAAW,OAAO,KAAG,OACiB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/openDatabase/index.d.ts

@@ -0,0 +1,2 @@
+export { openDatabase } from './openDatabase';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/openDatabase/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/openDatabase/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/openDatabase/openDatabase.d.ts

@@ -0,0 +1,31 @@
+import type { StoreDatabaseConfig } from '../../resilientIndexedDbStore.types';
+type OpenDatabaseParams = {
+    /** Where the store keeps its records. */
+    database: StoreDatabaseConfig;
+};
+/**
+ * Opens the store's IndexedDB connection, recovering from a corrupted schema.
+ *
+ * If the database exists but is missing the expected object store (an upgrade
+ * interrupted by a reload on iOS WebKit leaves the database committed at its
+ * version with the store creation rolled back), it reopens at the next version
+ * so `onupgradeneeded` fires and recreates only the missing store. Stored data
+ * is preserved: the database is never deleted.
+ *
+ * @example
+ * ```ts
+ * const db = await openDatabase({
+ *   database: { dbName: 'dynamic_keychain', keyPath: 'keyName', storeName: 'keys' },
+ * });
+ * ```
+ *
+ * @param params.database - Where the store keeps its records.
+ * @returns An open connection whose object store is guaranteed to exist.
+ * @throws When IndexedDB refuses to open the database.
+ * @see withDatabase
+ * @see createResilientIndexedDbStore
+ * @notInstrumented
+ */
+export declare const openDatabase: ({ database, }: OpenDatabaseParams) => Promise<IDBDatabase>;
+export {};
+//# sourceMappingURL=openDatabase.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/openDatabase/openDatabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openDatabase.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/openDatabase/openDatabase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE/E,KAAK,kBAAkB,GAAG;IACxB,yCAAyC;IACzC,QAAQ,EAAE,mBAAmB,CAAC;CAC/B,CAAC;AAmCF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,YAAY,kBAEtB,kBAAkB,KAAG,OAAO,CAAC,WAAW,CAe1C,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/putRecord/index.d.ts

@@ -0,0 +1,2 @@
+export { putRecord } from './putRecord';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/putRecord/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/putRecord/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/putRecord/putRecord.d.ts

@@ -0,0 +1,37 @@
+type PutRecordParams<TValue> = {
+    /** An open connection to the store's database. */
+    db: IDBDatabase;
+    /** Name of the object store to write to. */
+    storeName: string;
+    /** The value to write. It carries its own key under the store's key path. */
+    value: TValue;
+};
+/**
+ * Writes a single record to an object store, resolving once the transaction
+ * commits.
+ *
+ * A successful request only means the write ran inside the transaction, and a
+ * transaction can still abort after that, so the caller learns the value is
+ * stored only once IndexedDB has committed it.
+ *
+ * The value is written as it is, through structured clone, so types that cannot
+ * be serialized (such as a non-extractable `CryptoKey`) survive the round trip.
+ *
+ * @example
+ * ```ts
+ * await putRecord({ db, storeName: 'keys', value: storedKey });
+ * ```
+ *
+ * @param params.db - An open connection to the store's database.
+ * @param params.storeName - Name of the object store to write to.
+ * @param params.value - The value to write.
+ * @returns A promise that resolves once the write is committed.
+ * @throws When IndexedDB rejects the write or the transaction does not commit.
+ * @see getTransactionError
+ * @see withDatabase
+ * @see applyMutation
+ * @notInstrumented
+ */
+export declare const putRecord: <TValue>({ db, storeName, value, }: PutRecordParams<TValue>) => Promise<void>;
+export {};
+//# sourceMappingURL=putRecord.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/putRecord/putRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"putRecord.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/putRecord/putRecord.ts"],"names":[],"mappings":"AAEA,KAAK,eAAe,CAAC,MAAM,IAAI;IAC7B,kDAAkD;IAClD,EAAE,EAAE,WAAW,CAAC;IAEhB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAElB,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,6BAI7B,eAAe,CAAC,MAAM,CAAC,KAAG,OAAO,CAAC,IAAI,CASrC,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/readStoredValue/index.d.ts

@@ -0,0 +1,2 @@
+export { readStoredValue } from './readStoredValue';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/readStoredValue/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/readStoredValue/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/readStoredValue/readStoredValue.d.ts

@@ -0,0 +1,42 @@
+import type { StoreDatabaseConfig, StoreReadResult } from '../../resilientIndexedDbStore.types';
+type ReadStoredValueParams = {
+    /** Where the store keeps its records. */
+    database: StoreDatabaseConfig;
+    /** Key of the value to read. */
+    key: string;
+    /** How long the read may keep retrying before reporting unavailability. */
+    timeoutMs: number;
+};
+/**
+ * Reads a value from IndexedDB, retrying with backoff while the database is
+ * unusable and resolving deterministically once the timeout budget is spent.
+ *
+ * Each attempt is bounded by whatever is left of the budget, so an open the
+ * browser leaves blocked and a request it never settles both end the read
+ * within the budget instead of holding it forever.
+ *
+ * The caller is usually a user waiting on an interaction, so the result is
+ * always one of found, absent, or unavailable: never a hanging promise and
+ * never a thrown IndexedDB error.
+ *
+ * @example
+ * ```ts
+ * const result = await readStoredValue<StoredKey>({
+ *   database,
+ *   key: 'session',
+ *   timeoutMs: DEFAULT_READ_TIMEOUT_MS,
+ * });
+ * ```
+ *
+ * @param params.database - Where the store keeps its records.
+ * @param params.key - Key of the value to read.
+ * @param params.timeoutMs - How long the read may keep retrying.
+ * @returns Whether the value was found, is absent, or could not be read.
+ * @see createResilientIndexedDbStore
+ * @see getBackoffDelay
+ * @see runWithTimeout
+ * @notInstrumented
+ */
+export declare const readStoredValue: <TValue>({ database, key, timeoutMs, }: ReadStoredValueParams) => Promise<StoreReadResult<TValue>>;
+export {};
+//# sourceMappingURL=readStoredValue.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/readStoredValue/readStoredValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readStoredValue.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/readStoredValue/readStoredValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,qBAAqB,GAAG;IAC3B,yCAAyC;IACzC,QAAQ,EAAE,mBAAmB,CAAC;IAE9B,gCAAgC;IAChC,GAAG,EAAE,MAAM,CAAC;IAEZ,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,eAAe,GAAU,MAAM,iCAIzC,qBAAqB,KAAG,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CA+BzD,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/replayTombstones/index.d.ts

@@ -0,0 +1,2 @@
+export { replayTombstones } from './replayTombstones';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/replayTombstones/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/replayTombstones/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/replayTombstones/replayTombstones.d.ts

@@ -0,0 +1,31 @@
+import type { Logger } from '../../../logger';
+import type { TombstoneStore } from '../createTombstoneStore';
+import type { WorkQueue } from '../createWorkQueue';
+type ReplayTombstonesParams<TValue> = {
+    /** Reports degraded storage. */
+    logger?: Logger;
+    /** Queue the deletions are registered with. */
+    queue: WorkQueue<TValue>;
+    /** Durable record of deletions that IndexedDB has not acknowledged. */
+    tombstones: TombstoneStore;
+};
+/**
+ * Re-queues the deletions an earlier instance recorded but IndexedDB never
+ * acknowledged, so a value the caller was told is gone cannot come back.
+ *
+ * @example
+ * ```ts
+ * await replayTombstones({ logger, queue, tombstones });
+ * ```
+ *
+ * @param params.logger - Reports degraded storage.
+ * @param params.queue - Queue the deletions are registered with.
+ * @param params.tombstones - Durable record of unacknowledged deletions.
+ * @returns A promise that resolves once the deletions are queued.
+ * @see createResilientIndexedDbStore
+ * @see createTombstoneStore
+ * @notInstrumented
+ */
+export declare const replayTombstones: <TValue>({ logger, queue, tombstones, }: ReplayTombstonesParams<TValue>) => Promise<void>;
+export {};
+//# sourceMappingURL=replayTombstones.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/replayTombstones/replayTombstones.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replayTombstones.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/replayTombstones/replayTombstones.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,KAAK,sBAAsB,CAAC,MAAM,IAAI;IACpC,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,+CAA+C;IAC/C,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAEzB,uEAAuE;IACvE,UAAU,EAAE,cAAc,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,GAAU,MAAM,kCAI1C,sBAAsB,CAAC,MAAM,CAAC,KAAG,OAAO,CAAC,IAAI,CAgB/C,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/runWithTimeout/index.d.ts

@@ -0,0 +1,2 @@
+export { runWithTimeout } from './runWithTimeout';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/runWithTimeout/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/runWithTimeout/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/runWithTimeout/runWithTimeout.d.ts

@@ -0,0 +1,34 @@
+type RunWithTimeoutParams<TResult> = {
+    /** Runs when the budget is spent, to release what the operation acquired. */
+    onTimeout?: () => void;
+    /** Work that may never settle. */
+    operation: Promise<TResult>;
+    /** How long the operation may take before it is given up on. */
+    timeoutMs: number;
+};
+/**
+ * Bounds work that may never settle, which an IndexedDB request can do: an
+ * open blocked by another connection emits neither success nor error, and a
+ * request on a connection the browser closed can stay pending.
+ *
+ * @example
+ * ```ts
+ * const db = await runWithTimeout({
+ *   operation: openDatabase({ database }),
+ *   timeoutMs: DATABASE_OPERATION_TIMEOUT_MS,
+ * });
+ * ```
+ *
+ * @param params.onTimeout - Runs when the budget is spent.
+ * @param params.operation - Work that may never settle.
+ * @param params.timeoutMs - How long the operation may take.
+ * @returns Whatever the operation resolves with.
+ * @throws A `TimeoutError` `DOMException` once the budget is spent, or whatever
+ * the operation rejects with.
+ * @see withDatabase
+ * @see createWorkQueue
+ * @notInstrumented
+ */
+export declare const runWithTimeout: <TResult>({ onTimeout, operation, timeoutMs, }: RunWithTimeoutParams<TResult>) => Promise<TResult>;
+export {};
+//# sourceMappingURL=runWithTimeout.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/runWithTimeout/runWithTimeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runWithTimeout.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/runWithTimeout/runWithTimeout.ts"],"names":[],"mappings":"AAAA,KAAK,oBAAoB,CAAC,OAAO,IAAI;IACnC,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IAEvB,kCAAkC;IAClC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAE5B,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,wCAInC,oBAAoB,CAAC,OAAO,CAAC,KAAG,OAAO,CAAC,OAAO,CAyB9C,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/withDatabase/index.d.ts

@@ -0,0 +1,2 @@
+export { withDatabase } from './withDatabase';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/withDatabase/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/withDatabase/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/withDatabase/withDatabase.d.ts

@@ -0,0 +1,39 @@
+import type { StoreDatabaseConfig } from '../../resilientIndexedDbStore.types';
+type WithDatabaseParams<TResult> = {
+    /** Where the store keeps its records. */
+    database: StoreDatabaseConfig;
+    /** Work to run against an open connection. */
+    operation: (db: IDBDatabase) => Promise<TResult>;
+    /** How long one open-and-operate attempt may take. */
+    timeoutMs?: number;
+};
+/**
+ * Scopes a database connection to the lifetime of a callback.
+ *
+ * Opens a connection, passes it to the operation, and closes the connection
+ * once the operation completes or throws. Retries once with a fresh connection
+ * on a transient IndexedDB error, and gives each attempt up before its timeout
+ * so an open or a request that settles neither way cannot hang the caller.
+ *
+ * @example
+ * ```ts
+ * const record = await withDatabase({
+ *   database,
+ *   operation: (db) => getRecord({ db, key: 'session', storeName: 'keys' }),
+ * });
+ * ```
+ *
+ * @param params.database - Where the store keeps its records.
+ * @param params.operation - Work to run against an open connection.
+ * @param params.timeoutMs - How long one attempt may take.
+ * @returns Whatever the operation resolves with.
+ * @throws When the operation fails and is not retryable, fails twice, or does
+ * not settle within the timeout.
+ * @see openDatabase
+ * @see runWithTimeout
+ * @see applyMutation
+ * @notInstrumented
+ */
+export declare const withDatabase: <TResult>(params: WithDatabaseParams<TResult>) => Promise<TResult>;
+export {};
+//# sourceMappingURL=withDatabase.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/withDatabase/withDatabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withDatabase.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/withDatabase/withDatabase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAK/E,KAAK,kBAAkB,CAAC,OAAO,IAAI;IACjC,yCAAyC;IACzC,QAAQ,EAAE,mBAAmB,CAAC;IAE9B,8CAA8C;IAC9C,SAAS,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAEjD,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAmDF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,YAAY,GAAU,OAAO,UAChC,kBAAkB,CAAC,OAAO,CAAC,KAClC,OAAO,CAAC,OAAO,CAUjB,CAAC"}