@ttt-productions/query-core 0.14.4 → 0.14.6

package/dist/react/firestore/useBatchFirestoreDocs.js

@@ -1,9 +1,20 @@
 'use client';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useQueries, useQueryClient } from '@tanstack/react-query';
-import { isListenerOwned, subscribeDoc } from './doc-subscription-registry.js';
+import { isListenerOwned, listenerErrorOf, subscribeDoc } from './doc-subscription-registry.js';
 import { getDocLoader } from './batch-doc-loader.js';
 import { ABSENT_RETRY_DELAYS_MS, trackAbsentDoc } from './absence-scheduler.js';
+const LOADING_OUTCOME = { status: 'loading' };
+const ABSENT_OUTCOME = { status: 'absent' };
+function sameOutcome(a, b) {
+    if (a.status !== b.status)
+        return false;
+    if (a.status === 'present')
+        return a.data === b.data;
+    if (a.status === 'failed')
+        return a.error === b.error;
+    return true;
+}
 function shallowRecordEqual(a, b) {
     const aKeys = Object.keys(a);
     if (aKeys.length !== Object.keys(b).length)
@@ -27,6 +38,9 @@ function shallowRecordEqual(a, b) {
  * an absent id is then re-read on a bounded ladder (see `absentRetryDelaysMs`) so a doc
  * that appears shortly afterwards shows up without an invalidation.
  *
+ * Each id's own answer — loading, present, absent, or failed with its own error — is in
+ * `outcomes`; the aggregate fields cannot tell an absent id from a failed one.
+ *
  * @example
  * ```typescript
  * const { data: users, isLoading } = useBatchFirestoreDocs<PublicUser>({
@@ -50,8 +64,8 @@ export function useBatchFirestoreDocs({ db, collectionPath, ids, queryKeyPrefix,
     }, [idsKey]);
     // ── Real-time subscribe mode ──────────────────────────────────────────────
     // Listener errors cannot surface through the per-id queries (they are disabled while
-    // subscribed), so they are tracked here and merged into the returned result.
-    const [subscribeError, setSubscribeError] = useState(null);
+    // subscribed), so they are tracked here, per id, and merged into the returned result.
+    const [subscribeErrors, setSubscribeErrors] = useState({});
     // Snapshot re-render trigger. The per-id query observers do notify on the listener's
     // cache write, but only on React Query's batched microtask; bumping state in the
     // snapshot callback keeps a landed snapshot visible in the SAME tick it arrives.
@@ -64,8 +78,12 @@ export function useBatchFirestoreDocs({ db, collectionPath, ids, queryKeyPrefix,
                 const loaded = transport === 'get' ? await loader.loadOne(id, signal) : await loader.loadBatched(id, signal);
                 // If a shared listener took ownership of this key while the read was in flight, the
                 // listener's value is the newer truth — `onSnapshot` will not re-emit until the doc
-                // changes, so returning the read result here would leave a stale value stuck.
+                // changes, so returning the read result here would leave a stale value stuck. A listener
+                // that errored left only a `null` placeholder; its error is the answer, never an absence.
                 if (isListenerOwned(queryClient, queryKeyPrefix, id)) {
+                    const listenerError = listenerErrorOf(queryClient, queryKeyPrefix, id);
+                    if (listenerError)
+                        throw listenerError;
                     const owned = queryClient.getQueryData([queryKeyPrefix, id]);
                     if (owned !== undefined)
                         return owned;
@@ -86,15 +104,23 @@ export function useBatchFirestoreDocs({ db, collectionPath, ids, queryKeyPrefix,
     useEffect(() => {
         if (!subscribe || !enabled || uniqueIds.length === 0)
             return;
-        setSubscribeError(null);
+        setSubscribeErrors({});
         const unsubscribers = uniqueIds.map((id) => subscribeDoc({
             queryClient,
             db,
             collectionPath,
             queryKeyPrefix,
             id,
-            onUpdate: () => setSnapshotVersion((version) => version + 1),
-            onError: (error) => setSubscribeError(error),
+            onUpdate: () => {
+                setSubscribeErrors((errors) => {
+                    if (!(id in errors))
+                        return errors;
+                    const { [id]: _cleared, ...rest } = errors;
+                    return rest;
+                });
+                setSnapshotVersion((version) => version + 1);
+            },
+            onError: (error) => setSubscribeErrors((errors) => (errors[id] === error ? errors : { ...errors, [id]: error })),
         }));
         return () => {
             for (const unsubscribe of unsubscribers)
@@ -115,36 +141,63 @@ export function useBatchFirestoreDocs({ db, collectionPath, ids, queryKeyPrefix,
                 release();
         };
     }, [uniqueIds, queryKeyPrefix, queryClient, absentDelays]);
+    // The maps are rebuilt every render; the committed refs below hand back the last
+    // COMMITTED objects while nothing changed, so consumers can depend on their identity. Only
+    // the effect writes the refs, so a concurrent render React discards can never leave them
+    // pointing at an uncommitted map.
+    const committedDataRef = useRef({});
+    const committedOutcomesRef = useRef({});
     const nextData = {};
+    const nextOutcomes = {};
     let anyError = null;
+    let anyListenerError = null;
     let oneShotLoading = false;
     let anyUnresolved = false;
     for (let index = 0; index < uniqueIds.length; index += 1) {
+        const id = uniqueIds[index];
         const result = results[index];
-        if (!result)
-            continue;
-        if (result.isError) {
-            anyError ??= result.error ?? null;
-            continue;
+        let outcome = LOADING_OUTCOME;
+        // A one-shot reader of a key a failed shared listener owns sees that listener's `null`
+        // placeholder in the cache; the registry's error is what it stands for.
+        const listenerError = (subscribe ? subscribeErrors[id] : undefined) ??
+            listenerErrorOf(queryClient, queryKeyPrefix, id) ??
+            undefined;
+        if (result?.isError) {
+            const error = result.error;
+            anyError ??= error;
+            outcome = { status: 'failed', error };
+        }
+        else if (result) {
+            if (result.isLoading)
+                oneShotLoading = true;
+            const value = result.data;
+            if (value === undefined)
+                anyUnresolved = true;
+            if (listenerError) {
+                anyListenerError ??= listenerError;
+                outcome = { status: 'failed', error: listenerError };
+            }
+            else if (value === null) {
+                outcome = ABSENT_OUTCOME;
+            }
+            else if (value !== undefined) {
+                nextData[id] = value;
+                outcome = { status: 'present', data: value };
+            }
         }
-        if (result.isLoading)
-            oneShotLoading = true;
-        const value = result.data;
-        if (value === undefined)
-            anyUnresolved = true;
-        else if (value)
-            nextData[uniqueIds[index]] = value;
+        const committed = committedOutcomesRef.current[id];
+        nextOutcomes[id] = committed && sameOutcome(committed, outcome) ? committed : outcome;
     }
-    // The map is rebuilt every render; keep the last COMMITTED object while it is unchanged so
-    // consumers can safely depend on `data`'s identity. Only the effect writes the ref, so a
-    // concurrent render React discards can never leave it pointing at an uncommitted map.
-    const committedDataRef = useRef(nextData);
     const data = shallowRecordEqual(committedDataRef.current, nextData)
         ? committedDataRef.current
         : nextData;
+    const outcomes = shallowRecordEqual(committedOutcomesRef.current, nextOutcomes)
+        ? committedOutcomesRef.current
+        : nextOutcomes;
     useEffect(() => {
         committedDataRef.current = data;
-    }, [data]);
+        committedOutcomesRef.current = outcomes;
+    }, [data, outcomes]);
     const refetch = useCallback(async () => {
         // Subscribe mode owns its freshness through the shared listeners — refetching would
         // issue reads against disabled queries and race the listener's value.
@@ -158,8 +211,9 @@ export function useBatchFirestoreDocs({ db, collectionPath, ids, queryKeyPrefix,
     return {
         data,
         isLoading,
-        isError: anyError !== null || subscribeError !== null,
-        error: anyError ?? subscribeError,
+        isError: anyError !== null || anyListenerError !== null,
+        error: anyError ?? anyListenerError,
+        outcomes,
         refetch,
     };
 }

package/dist/react/firestore/useBatchFirestoreDocs.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBatchFirestoreDocs.js","sourceRoot":"","sources":["../../../src/react/firestore/useBatchFirestoreDocs.ts"],"names":[],"mappings":"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","sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\nimport { useQueries, useQueryClient } from '@tanstack/react-query';\nimport type { Firestore } from 'firebase/firestore';\nimport { isListenerOwned, subscribeDoc } from './doc-subscription-registry.js';\nimport { getDocLoader } from './batch-doc-loader.js';\nimport { ABSENT_RETRY_DELAYS_MS, trackAbsentDoc } from './absence-scheduler.js';\n\n/** Transport used to resolve an id in one-shot mode. */\nexport type BatchFirestoreDocsTransport = 'batch' | 'get';\n\nexport type BatchFirestoreDocsOptions = {\n  /**\n   * Firestore instance to use for queries\n   */\n  db: Firestore;\n\n  /**\n   * Full collection path (e.g., 'publicUsers', 'entities/public')\n   */\n  collectionPath: string;\n\n  /**\n   * Array of document IDs to fetch\n   */\n  ids: string[];\n\n  /**\n   * Query key prefix for individual document cache entries\n   * Each document is cached as [queryKeyPrefix, docId]\n   * @example 'publicUser' -> ['publicUser', 'user123']\n   */\n  queryKeyPrefix: string;\n\n  /**\n   * Time in milliseconds a PRESENT document stays fresh (default: 30 minutes).\n   * An absent document uses `absentStaleTime` instead.\n   */\n  staleTime?: number;\n\n  /**\n   * Time in milliseconds to keep unused data in cache (default: 1 hour)\n   */\n  gcTime?: number;\n\n  /**\n   * Whether queries should be enabled (default: true)\n   */\n  enabled?: boolean;\n\n  /**\n   * Real-time mode (default: false). When true, each id is resolved via a shared,\n   * reference-counted `onSnapshot` listener instead of a one-shot read:\n   * - a missing doc caches `null` (negative caching) and resolves the instant it appears,\n   * - identity edits propagate live, and every browser tab stays consistent,\n   * - `staleTime` is irrelevant (listeners keep the cache fresh) and `refetch()` is a no-op.\n   * Initial read cost matches the one-shot path; listeners then stay open while mounted.\n   * Use for small, frequently-rendered, change-sensitive docs owned by the signed-in user.\n   */\n  subscribe?: boolean;\n\n  /**\n   * One-shot transport (default: `'batch'`).\n   *\n   * - `'batch'` — ids enqueued in the same microtask are coalesced into\n   *   `where(documentId(), 'in', …)` queries of at most 30 ids each. Fewest round-trips.\n   * - `'get'` — one `getDoc` per id, run concurrently. Required for a collection whose\n   *   Firestore rules gate reads on `resource.data`: an unconstrained id-list query is\n   *   denied WHOLESALE there, while per-document gets are evaluated per document, so one\n   *   unreadable id errors alone instead of failing every id with it. On such a collection\n   *   a get against a nonexistent doc is also denied, so \"absent\" and \"hidden\" are the same\n   *   client-visible signal — the id surfaces as that query's error, never as a null.\n   */\n  transport?: BatchFirestoreDocsTransport;\n\n  /**\n   * Time in milliseconds an ABSENT (`null`) result stays fresh (default: 30 seconds).\n   * Deliberately much shorter than `staleTime`: a missing doc is usually a doc that has\n   * not been mirrored/created YET, and holding \"missing\" as fresh for the full staleTime\n   * is what leaves a row blank long after the doc appears.\n   */\n  absentStaleTime?: number;\n\n  /**\n   * Backoff ladder (ms) for re-reading an id that resolved absent, one re-read per rung\n   * per absence episode (default: {@link ABSENT_RETRY_DELAYS_MS}). Pass `[]` to ask for no\n   * re-reads.\n   *\n   * The timer is per cache key, so many consumers of the same absent id still cost one\n   * re-read per rung — and consumers that disagree combine by UNION, never by mount order:\n   * the key polls if ANY mounted consumer wants polling, on the LONGEST ladder among them.\n   * `[]` therefore only silences re-reads that no other mounted consumer asked for. The\n   * effective ladder is recomputed on every mount and unmount; an episode already in\n   * progress continues on the new ladder's remaining rungs, or stops if it is now empty.\n   */\n  absentRetryDelaysMs?: readonly number[];\n};\n\nexport type BatchFirestoreDocsResult<T> = {\n  /**\n   * Map of docId -> document data.\n   * Only includes documents that exist AND are currently readable: an id whose query is in\n   * an error state is excluded, so a previously cached doc is never presented as readable\n   * after access to it fails.\n   */\n  data: Record<string, T>;\n\n  /**\n   * True while any requested id has not resolved yet\n   */\n  isLoading: boolean;\n\n  /**\n   * True if any requested id is in an error state\n   */\n  isError: boolean;\n\n  /**\n   * First error across the requested ids, if any\n   */\n  error: Error | null;\n\n  /**\n   * Refetch every requested id, cached ones included. A no-op in subscribe mode.\n   */\n  refetch: () => Promise<void>;\n};\n\nfunction shallowRecordEqual<T>(a: Record<string, T>, b: Record<string, T>): boolean {\n  const aKeys = Object.keys(a);\n  if (aKeys.length !== Object.keys(b).length) return false;\n  for (const key of aKeys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key) || a[key] !== b[key]) return false;\n  }\n  return true;\n}\n\n/**\n * Resolve many document ids into individually observed, individually cached React Query\n * entries at `[queryKeyPrefix, id]`.\n *\n * There is exactly ONE data cache: the per-id entries. Each id owns a real query with a\n * real `queryFn`, so exact-key invalidation, `refetchQueries({ type: 'active' })`, and\n * `refetchOnMount` all work on a single id the way they work on any other query — and the\n * returned `data` is derived reactively from those query results, never read imperatively.\n *\n * A nonexistent document resolves to `null` (negative caching) and is excluded from `data`;\n * an absent id is then re-read on a bounded ladder (see `absentRetryDelaysMs`) so a doc\n * that appears shortly afterwards shows up without an invalidation.\n *\n * @example\n * ```typescript\n * const { data: users, isLoading } = useBatchFirestoreDocs<PublicUser>({\n *   db,\n *   collectionPath: 'publicUsers',\n *   ids: ['user1', 'user2', 'user3'],\n *   queryKeyPrefix: 'publicUser',\n *   staleTime: 30 * 60 * 1000,\n * });\n * // users = { user1: {...}, user2: {...}, user3: {...} }\n * ```\n */\nexport function useBatchFirestoreDocs<T extends Record<string, any>>({\n  db,\n  collectionPath,\n  ids,\n  queryKeyPrefix,\n  staleTime = 30 * 60 * 1000,\n  gcTime = 60 * 60 * 1000,\n  enabled = true,\n  subscribe = false,\n  transport = 'batch',\n  absentStaleTime = 30 * 1000,\n  absentRetryDelaysMs = ABSENT_RETRY_DELAYS_MS,\n}: BatchFirestoreDocsOptions): BatchFirestoreDocsResult<T> {\n  const queryClient = useQueryClient();\n\n  // Stabilize ids reference to prevent cascading re-renders\n  const idsKey = JSON.stringify(ids);\n\n  // Deduplicate and filter out empty IDs\n  const uniqueIds = useMemo(() => {\n    const parsed: string[] = JSON.parse(idsKey);\n    return Array.from(new Set(parsed.filter(Boolean)));\n  }, [idsKey]);\n\n  // ── Real-time subscribe mode ──────────────────────────────────────────────\n  // Listener errors cannot surface through the per-id queries (they are disabled while\n  // subscribed), so they are tracked here and merged into the returned result.\n  const [subscribeError, setSubscribeError] = useState<Error | null>(null);\n  // Snapshot re-render trigger. The per-id query observers do notify on the listener's\n  // cache write, but only on React Query's batched microtask; bumping state in the\n  // snapshot callback keeps a landed snapshot visible in the SAME tick it arrives.\n  const [, setSnapshotVersion] = useState(0);\n\n  const results = useQueries({\n    queries: uniqueIds.map((id) => ({\n      queryKey: [queryKeyPrefix, id],\n      queryFn: async ({ signal }: { signal: AbortSignal }): Promise<T | null> => {\n        const loader = getDocLoader(queryClient, db, collectionPath);\n        const loaded =\n          transport === 'get' ? await loader.loadOne(id, signal) : await loader.loadBatched(id, signal);\n        // If a shared listener took ownership of this key while the read was in flight, the\n        // listener's value is the newer truth — `onSnapshot` will not re-emit until the doc\n        // changes, so returning the read result here would leave a stale value stuck.\n        if (isListenerOwned(queryClient, queryKeyPrefix, id)) {\n          const owned = queryClient.getQueryData([queryKeyPrefix, id]);\n          if (owned !== undefined) return owned as T | null;\n        }\n        return loaded as T | null;\n      },\n      enabled: enabled && !subscribe,\n      // The consuming app's global default is `refetchOnMount: false`; these lookups opt\n      // back in so a remount re-reads a STALE id (refetch-on-mount never fires on a fresh\n      // one, so an all-cache-hit mount still costs nothing).\n      refetchOnMount: !subscribe,\n      staleTime: subscribe\n        ? Infinity\n        : (query: { state: { data: unknown } }) =>\n            query.state.data === null ? absentStaleTime : staleTime,\n      gcTime,\n    })),\n  });\n\n  useEffect(() => {\n    if (!subscribe || !enabled || uniqueIds.length === 0) return;\n    setSubscribeError(null);\n    const unsubscribers = uniqueIds.map((id) =>\n      subscribeDoc({\n        queryClient,\n        db,\n        collectionPath,\n        queryKeyPrefix,\n        id,\n        onUpdate: () => setSnapshotVersion((version) => version + 1),\n        onError: (error) => setSubscribeError(error),\n      }),\n    );\n    return () => {\n      for (const unsubscribe of unsubscribers) unsubscribe();\n    };\n  }, [uniqueIds, subscribe, enabled, collectionPath, queryKeyPrefix, queryClient, db]);\n\n  // Bounded re-read ladder for ids that resolved absent. Registration is per cache key, so\n  // overlapping consumers share one episode budget. The ladder is rebuilt from its own\n  // serialized form so an inline array literal cannot re-register (and reset it) every render.\n  const absentDelaysKey = absentRetryDelaysMs.join(',');\n  const absentDelays = useMemo(\n    () => absentDelaysKey.split(',').filter(Boolean).map(Number),\n    [absentDelaysKey],\n  );\n\n  useEffect(() => {\n    if (uniqueIds.length === 0) return;\n    const releases = uniqueIds.map((id) =>\n      trackAbsentDoc({ queryClient, queryKey: [queryKeyPrefix, id], delays: absentDelays }),\n    );\n    return () => {\n      for (const release of releases) release();\n    };\n  }, [uniqueIds, queryKeyPrefix, queryClient, absentDelays]);\n\n  const nextData: Record<string, T> = {};\n  let anyError: Error | null = null;\n  let oneShotLoading = false;\n  let anyUnresolved = false;\n\n  for (let index = 0; index < uniqueIds.length; index += 1) {\n    const result = results[index];\n    if (!result) continue;\n    if (result.isError) {\n      anyError ??= (result.error as Error | null) ?? null;\n      continue;\n    }\n    if (result.isLoading) oneShotLoading = true;\n    const value = result.data as T | null | undefined;\n    if (value === undefined) anyUnresolved = true;\n    else if (value) nextData[uniqueIds[index]] = value;\n  }\n\n  // The map is rebuilt every render; keep the last COMMITTED object while it is unchanged so\n  // consumers can safely depend on `data`'s identity. Only the effect writes the ref, so a\n  // concurrent render React discards can never leave it pointing at an uncommitted map.\n  const committedDataRef = useRef<Record<string, T>>(nextData);\n  const data = shallowRecordEqual(committedDataRef.current, nextData)\n    ? committedDataRef.current\n    : nextData;\n\n  useEffect(() => {\n    committedDataRef.current = data;\n  }, [data]);\n\n  const refetch = useCallback(async () => {\n    // Subscribe mode owns its freshness through the shared listeners — refetching would\n    // issue reads against disabled queries and race the listener's value.\n    if (subscribe || !enabled) return;\n    await Promise.all(\n      uniqueIds.map((id) =>\n        queryClient.refetchQueries({ queryKey: [queryKeyPrefix, id], exact: true }),\n      ),\n    );\n  }, [uniqueIds, subscribe, enabled, queryClient, queryKeyPrefix]);\n\n  // In subscribe mode \"loading\" means a subscribed id has no cache entry yet (`null`\n  // counts as resolved-missing).\n  const isLoading = subscribe ? enabled && anyUnresolved : oneShotLoading;\n\n  return {\n    data,\n    isLoading,\n    isError: anyError !== null || subscribeError !== null,\n    error: anyError ?? subscribeError,\n    refetch,\n  };\n}\n"]}
+{"version":3,"file":"useBatchFirestoreDocs.js","sourceRoot":"","sources":["../../../src/react/firestore/useBatchFirestoreDocs.ts"],"names":[],"mappings":"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","sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\nimport { useQueries, useQueryClient } from '@tanstack/react-query';\nimport type { Firestore } from 'firebase/firestore';\nimport { isListenerOwned, listenerErrorOf, subscribeDoc } from './doc-subscription-registry.js';\nimport { getDocLoader } from './batch-doc-loader.js';\nimport { ABSENT_RETRY_DELAYS_MS, trackAbsentDoc } from './absence-scheduler.js';\nimport type { BatchFirestoreDocOutcome } from '../../firestore/types.js';\n\n/** Transport used to resolve an id in one-shot mode. */\nexport type BatchFirestoreDocsTransport = 'batch' | 'get';\n\nexport type BatchFirestoreDocsOptions = {\n  /**\n   * Firestore instance to use for queries\n   */\n  db: Firestore;\n\n  /**\n   * Full collection path (e.g., 'publicUsers', 'entities/public')\n   */\n  collectionPath: string;\n\n  /**\n   * Array of document IDs to fetch\n   */\n  ids: string[];\n\n  /**\n   * Query key prefix for individual document cache entries\n   * Each document is cached as [queryKeyPrefix, docId]\n   * @example 'publicUser' -> ['publicUser', 'user123']\n   */\n  queryKeyPrefix: string;\n\n  /**\n   * Time in milliseconds a PRESENT document stays fresh (default: 30 minutes).\n   * An absent document uses `absentStaleTime` instead.\n   */\n  staleTime?: number;\n\n  /**\n   * Time in milliseconds to keep unused data in cache (default: 1 hour)\n   */\n  gcTime?: number;\n\n  /**\n   * Whether queries should be enabled (default: true)\n   */\n  enabled?: boolean;\n\n  /**\n   * Real-time mode (default: false). When true, each id is resolved via a shared,\n   * reference-counted `onSnapshot` listener instead of a one-shot read:\n   * - a missing doc caches `null` (negative caching) and resolves the instant it appears,\n   * - identity edits propagate live, and every browser tab stays consistent,\n   * - `staleTime` is irrelevant (listeners keep the cache fresh) and `refetch()` is a no-op.\n   * Initial read cost matches the one-shot path; listeners then stay open while mounted.\n   * Use for small, frequently-rendered, change-sensitive docs owned by the signed-in user.\n   */\n  subscribe?: boolean;\n\n  /**\n   * One-shot transport (default: `'batch'`).\n   *\n   * - `'batch'` — ids enqueued in the same microtask are coalesced into\n   *   `where(documentId(), 'in', …)` queries of at most 30 ids each. Fewest round-trips.\n   * - `'get'` — one `getDoc` per id, run concurrently. Required for a collection whose\n   *   Firestore rules gate reads on `resource.data`: an unconstrained id-list query is\n   *   denied WHOLESALE there, while per-document gets are evaluated per document, so one\n   *   unreadable id errors alone instead of failing every id with it. On such a collection\n   *   a get against a nonexistent doc is also denied, so \"absent\" and \"hidden\" are the same\n   *   client-visible signal — the id surfaces as that query's error, never as a null.\n   */\n  transport?: BatchFirestoreDocsTransport;\n\n  /**\n   * Time in milliseconds an ABSENT (`null`) result stays fresh (default: 30 seconds).\n   * Deliberately much shorter than `staleTime`: a missing doc is usually a doc that has\n   * not been mirrored/created YET, and holding \"missing\" as fresh for the full staleTime\n   * is what leaves a row blank long after the doc appears.\n   */\n  absentStaleTime?: number;\n\n  /**\n   * Backoff ladder (ms) for re-reading an id that resolved absent, one re-read per rung\n   * per absence episode (default: {@link ABSENT_RETRY_DELAYS_MS}). Pass `[]` to ask for no\n   * re-reads.\n   *\n   * The timer is per cache key, so many consumers of the same absent id still cost one\n   * re-read per rung — and consumers that disagree combine by UNION, never by mount order:\n   * the key polls if ANY mounted consumer wants polling, on the LONGEST ladder among them.\n   * `[]` therefore only silences re-reads that no other mounted consumer asked for. The\n   * effective ladder is recomputed on every mount and unmount; an episode already in\n   * progress continues on the new ladder's remaining rungs, or stops if it is now empty.\n   */\n  absentRetryDelaysMs?: readonly number[];\n};\n\nexport type BatchFirestoreDocsResult<T> = {\n  /**\n   * Map of docId -> document data.\n   * Only includes documents that exist AND are currently readable: an id whose query is in\n   * an error state is excluded, so a previously cached doc is never presented as readable\n   * after access to it fails.\n   */\n  data: Record<string, T>;\n\n  /**\n   * True while any requested id has not resolved yet\n   */\n  isLoading: boolean;\n\n  /**\n   * True if any requested id is in an error state\n   */\n  isError: boolean;\n\n  /**\n   * First error across the requested ids, if any\n   */\n  error: Error | null;\n\n  /**\n   * One entry per requested id (empty ids and duplicates dropped): `loading`, `present` with\n   * its data, `absent`, or `failed` with that id's own error. A multi-id consumer reads which\n   * ids are missing and which failed here — `data` / `isError` / `error` are the aggregate\n   * view and cannot tell them apart. The map, and each unchanged entry, keep their identity\n   * across renders.\n   */\n  outcomes: Record<string, BatchFirestoreDocOutcome<T>>;\n\n  /**\n   * Refetch every requested id, cached ones included. A no-op in subscribe mode.\n   */\n  refetch: () => Promise<void>;\n};\n\nconst LOADING_OUTCOME = { status: 'loading' } as const;\nconst ABSENT_OUTCOME = { status: 'absent' } as const;\n\nfunction sameOutcome<T>(a: BatchFirestoreDocOutcome<T>, b: BatchFirestoreDocOutcome<T>): boolean {\n  if (a.status !== b.status) return false;\n  if (a.status === 'present') return a.data === (b as { data: T }).data;\n  if (a.status === 'failed') return a.error === (b as { error: Error }).error;\n  return true;\n}\n\nfunction shallowRecordEqual<T>(a: Record<string, T>, b: Record<string, T>): boolean {\n  const aKeys = Object.keys(a);\n  if (aKeys.length !== Object.keys(b).length) return false;\n  for (const key of aKeys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key) || a[key] !== b[key]) return false;\n  }\n  return true;\n}\n\n/**\n * Resolve many document ids into individually observed, individually cached React Query\n * entries at `[queryKeyPrefix, id]`.\n *\n * There is exactly ONE data cache: the per-id entries. Each id owns a real query with a\n * real `queryFn`, so exact-key invalidation, `refetchQueries({ type: 'active' })`, and\n * `refetchOnMount` all work on a single id the way they work on any other query — and the\n * returned `data` is derived reactively from those query results, never read imperatively.\n *\n * A nonexistent document resolves to `null` (negative caching) and is excluded from `data`;\n * an absent id is then re-read on a bounded ladder (see `absentRetryDelaysMs`) so a doc\n * that appears shortly afterwards shows up without an invalidation.\n *\n * Each id's own answer — loading, present, absent, or failed with its own error — is in\n * `outcomes`; the aggregate fields cannot tell an absent id from a failed one.\n *\n * @example\n * ```typescript\n * const { data: users, isLoading } = useBatchFirestoreDocs<PublicUser>({\n *   db,\n *   collectionPath: 'publicUsers',\n *   ids: ['user1', 'user2', 'user3'],\n *   queryKeyPrefix: 'publicUser',\n *   staleTime: 30 * 60 * 1000,\n * });\n * // users = { user1: {...}, user2: {...}, user3: {...} }\n * ```\n */\nexport function useBatchFirestoreDocs<T extends Record<string, any>>({\n  db,\n  collectionPath,\n  ids,\n  queryKeyPrefix,\n  staleTime = 30 * 60 * 1000,\n  gcTime = 60 * 60 * 1000,\n  enabled = true,\n  subscribe = false,\n  transport = 'batch',\n  absentStaleTime = 30 * 1000,\n  absentRetryDelaysMs = ABSENT_RETRY_DELAYS_MS,\n}: BatchFirestoreDocsOptions): BatchFirestoreDocsResult<T> {\n  const queryClient = useQueryClient();\n\n  // Stabilize ids reference to prevent cascading re-renders\n  const idsKey = JSON.stringify(ids);\n\n  // Deduplicate and filter out empty IDs\n  const uniqueIds = useMemo(() => {\n    const parsed: string[] = JSON.parse(idsKey);\n    return Array.from(new Set(parsed.filter(Boolean)));\n  }, [idsKey]);\n\n  // ── Real-time subscribe mode ──────────────────────────────────────────────\n  // Listener errors cannot surface through the per-id queries (they are disabled while\n  // subscribed), so they are tracked here, per id, and merged into the returned result.\n  const [subscribeErrors, setSubscribeErrors] = useState<Record<string, Error>>({});\n  // Snapshot re-render trigger. The per-id query observers do notify on the listener's\n  // cache write, but only on React Query's batched microtask; bumping state in the\n  // snapshot callback keeps a landed snapshot visible in the SAME tick it arrives.\n  const [, setSnapshotVersion] = useState(0);\n\n  const results = useQueries({\n    queries: uniqueIds.map((id) => ({\n      queryKey: [queryKeyPrefix, id],\n      queryFn: async ({ signal }: { signal: AbortSignal }): Promise<T | null> => {\n        const loader = getDocLoader(queryClient, db, collectionPath);\n        const loaded =\n          transport === 'get' ? await loader.loadOne(id, signal) : await loader.loadBatched(id, signal);\n        // If a shared listener took ownership of this key while the read was in flight, the\n        // listener's value is the newer truth — `onSnapshot` will not re-emit until the doc\n        // changes, so returning the read result here would leave a stale value stuck. A listener\n        // that errored left only a `null` placeholder; its error is the answer, never an absence.\n        if (isListenerOwned(queryClient, queryKeyPrefix, id)) {\n          const listenerError = listenerErrorOf(queryClient, queryKeyPrefix, id);\n          if (listenerError) throw listenerError;\n          const owned = queryClient.getQueryData([queryKeyPrefix, id]);\n          if (owned !== undefined) return owned as T | null;\n        }\n        return loaded as T | null;\n      },\n      enabled: enabled && !subscribe,\n      // The consuming app's global default is `refetchOnMount: false`; these lookups opt\n      // back in so a remount re-reads a STALE id (refetch-on-mount never fires on a fresh\n      // one, so an all-cache-hit mount still costs nothing).\n      refetchOnMount: !subscribe,\n      staleTime: subscribe\n        ? Infinity\n        : (query: { state: { data: unknown } }) =>\n            query.state.data === null ? absentStaleTime : staleTime,\n      gcTime,\n    })),\n  });\n\n  useEffect(() => {\n    if (!subscribe || !enabled || uniqueIds.length === 0) return;\n    setSubscribeErrors({});\n    const unsubscribers = uniqueIds.map((id) =>\n      subscribeDoc({\n        queryClient,\n        db,\n        collectionPath,\n        queryKeyPrefix,\n        id,\n        onUpdate: () => {\n          setSubscribeErrors((errors) => {\n            if (!(id in errors)) return errors;\n            const { [id]: _cleared, ...rest } = errors;\n            return rest;\n          });\n          setSnapshotVersion((version) => version + 1);\n        },\n        onError: (error) =>\n          setSubscribeErrors((errors) => (errors[id] === error ? errors : { ...errors, [id]: error })),\n      }),\n    );\n    return () => {\n      for (const unsubscribe of unsubscribers) unsubscribe();\n    };\n  }, [uniqueIds, subscribe, enabled, collectionPath, queryKeyPrefix, queryClient, db]);\n\n  // Bounded re-read ladder for ids that resolved absent. Registration is per cache key, so\n  // overlapping consumers share one episode budget. The ladder is rebuilt from its own\n  // serialized form so an inline array literal cannot re-register (and reset it) every render.\n  const absentDelaysKey = absentRetryDelaysMs.join(',');\n  const absentDelays = useMemo(\n    () => absentDelaysKey.split(',').filter(Boolean).map(Number),\n    [absentDelaysKey],\n  );\n\n  useEffect(() => {\n    if (uniqueIds.length === 0) return;\n    const releases = uniqueIds.map((id) =>\n      trackAbsentDoc({ queryClient, queryKey: [queryKeyPrefix, id], delays: absentDelays }),\n    );\n    return () => {\n      for (const release of releases) release();\n    };\n  }, [uniqueIds, queryKeyPrefix, queryClient, absentDelays]);\n\n  // The maps are rebuilt every render; the committed refs below hand back the last\n  // COMMITTED objects while nothing changed, so consumers can depend on their identity. Only\n  // the effect writes the refs, so a concurrent render React discards can never leave them\n  // pointing at an uncommitted map.\n  const committedDataRef = useRef<Record<string, T>>({});\n  const committedOutcomesRef = useRef<Record<string, BatchFirestoreDocOutcome<T>>>({});\n\n  const nextData: Record<string, T> = {};\n  const nextOutcomes: Record<string, BatchFirestoreDocOutcome<T>> = {};\n  let anyError: Error | null = null;\n  let anyListenerError: Error | null = null;\n  let oneShotLoading = false;\n  let anyUnresolved = false;\n\n  for (let index = 0; index < uniqueIds.length; index += 1) {\n    const id = uniqueIds[index];\n    const result = results[index];\n    let outcome: BatchFirestoreDocOutcome<T> = LOADING_OUTCOME;\n    // A one-shot reader of a key a failed shared listener owns sees that listener's `null`\n    // placeholder in the cache; the registry's error is what it stands for.\n    const listenerError =\n      (subscribe ? subscribeErrors[id] : undefined) ??\n      listenerErrorOf(queryClient, queryKeyPrefix, id) ??\n      undefined;\n    if (result?.isError) {\n      const error = result.error as Error;\n      anyError ??= error;\n      outcome = { status: 'failed', error };\n    } else if (result) {\n      if (result.isLoading) oneShotLoading = true;\n      const value = result.data as T | null | undefined;\n      if (value === undefined) anyUnresolved = true;\n      if (listenerError) {\n        anyListenerError ??= listenerError;\n        outcome = { status: 'failed', error: listenerError };\n      } else if (value === null) {\n        outcome = ABSENT_OUTCOME;\n      } else if (value !== undefined) {\n        nextData[id] = value;\n        outcome = { status: 'present', data: value };\n      }\n    }\n    const committed = committedOutcomesRef.current[id];\n    nextOutcomes[id] = committed && sameOutcome(committed, outcome) ? committed : outcome;\n  }\n\n  const data = shallowRecordEqual(committedDataRef.current, nextData)\n    ? committedDataRef.current\n    : nextData;\n  const outcomes = shallowRecordEqual(committedOutcomesRef.current, nextOutcomes)\n    ? committedOutcomesRef.current\n    : nextOutcomes;\n\n  useEffect(() => {\n    committedDataRef.current = data;\n    committedOutcomesRef.current = outcomes;\n  }, [data, outcomes]);\n\n  const refetch = useCallback(async () => {\n    // Subscribe mode owns its freshness through the shared listeners — refetching would\n    // issue reads against disabled queries and race the listener's value.\n    if (subscribe || !enabled) return;\n    await Promise.all(\n      uniqueIds.map((id) =>\n        queryClient.refetchQueries({ queryKey: [queryKeyPrefix, id], exact: true }),\n      ),\n    );\n  }, [uniqueIds, subscribe, enabled, queryClient, queryKeyPrefix]);\n\n  // In subscribe mode \"loading\" means a subscribed id has no cache entry yet (`null`\n  // counts as resolved-missing).\n  const isLoading = subscribe ? enabled && anyUnresolved : oneShotLoading;\n\n  return {\n    data,\n    isLoading,\n    isError: anyError !== null || anyListenerError !== null,\n    error: anyError ?? anyListenerError,\n    outcomes,\n    refetch,\n  };\n}\n"]}

package/dist/react/index.d.ts

@@ -6,7 +6,7 @@ export { FirestoreProvider, useFirestoreDb } from './firestore/context.js';
 export type { FirestoreProviderProps } from './firestore/context.js';
 export { useFirestoreDoc } from './firestore/use-firestore-doc.js';
 export { useFirestoreCollection } from './firestore/use-firestore-collection.js';
-export type { FirestoreSourceState, WithSourceState } from '../firestore/types.js';
+export type { FirestoreSourceState, WithSourceState, BatchFirestoreDocOutcome } from '../firestore/types.js';
 export { useFirestoreInfinite } from './firestore/use-firestore-infinite.js';
 export { useFirestorePaginated } from './firestore/use-firestore-paginated.js';
 export type { UseFirestorePaginatedResult } from './firestore/use-firestore-paginated.js';

package/dist/react/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,YAAY,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAGnE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGxD,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC3E,YAAY,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAGrE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC/E,YAAY,EAAE,2BAA2B,EAAE,MAAM,wCAAwC,CAAC;AAC1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACtF,YAAY,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AAG9F,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,wCAAwC,CAAC;AAGhD,OAAO,EACL,qBAAqB,GACtB,MAAM,sCAAsC,CAAC;AAC9C,YAAY,EACV,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAG1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,YAAY,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAGnE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGxD,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC3E,YAAY,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAGrE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAC7G,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC/E,YAAY,EAAE,2BAA2B,EAAE,MAAM,wCAAwC,CAAC;AAC1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACtF,YAAY,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AAG9F,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,wCAAwC,CAAC;AAGhD,OAAO,EACL,qBAAqB,GACtB,MAAM,sCAAsC,CAAC;AAC9C,YAAY,EACV,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAG1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/react/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,qEAAqE;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAGvD,WAAW;AACX,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG9C,qBAAqB;AACrB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG3E,wBAAwB;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAEjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AAGtF,2BAA2B;AAC3B,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,wCAAwC,CAAC;AAEhD,uBAAuB;AACvB,OAAO,EACL,qBAAqB,GACtB,MAAM,sCAAsC,CAAC;AAM9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE1E,cAAc;AACd,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC","sourcesContent":["\"use client\";\n\n// Query Client factory (client-only; requires @tanstack/react-query)\nexport { createQueryClient } from '../query-client.js';\nexport type { CreateQueryClientOptions } from '../query-client.js';\n\n// Provider\nexport { QueryProvider } from './provider.js';\nexport type { QueryProviderProps } from './provider.js';\n\n// Firestore Provider\nexport { FirestoreProvider, useFirestoreDb } from './firestore/context.js';\nexport type { FirestoreProviderProps } from './firestore/context.js';\n\n// Firestore Query Hooks\nexport { useFirestoreDoc } from './firestore/use-firestore-doc.js';\nexport { useFirestoreCollection } from './firestore/use-firestore-collection.js';\nexport type { FirestoreSourceState, WithSourceState } from '../firestore/types.js';\nexport { useFirestoreInfinite } from './firestore/use-firestore-infinite.js';\nexport { useFirestorePaginated } from './firestore/use-firestore-paginated.js';\nexport type { UseFirestorePaginatedResult } from './firestore/use-firestore-paginated.js';\nexport { useFirestoreCount } from './firestore/use-firestore-count.js';\nexport { useFirestoreLiveInfinite } from './firestore/use-firestore-live-infinite.js';\nexport type { FirestoreLiveInfiniteResult } from './firestore/use-firestore-live-infinite.js';\n\n// Firestore Mutation Hooks\nexport {\n  useFirestoreSet,\n  useFirestoreUpdate,\n  useFirestoreDelete,\n  useFirestoreBatch,\n} from './firestore/use-firestore-mutations.js';\n\n// Batch Firestore Docs\nexport {\n  useBatchFirestoreDocs,\n} from './firestore/useBatchFirestoreDocs.js';\nexport type {\n  BatchFirestoreDocsOptions,\n  BatchFirestoreDocsResult,\n  BatchFirestoreDocsTransport,\n} from './firestore/useBatchFirestoreDocs.js';\nexport { ABSENT_RETRY_DELAYS_MS } from './firestore/absence-scheduler.js';\n\n// Search Hook\nexport { useFirestoreSearch } from './search/use-firestore-search.js';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,qEAAqE;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAGvD,WAAW;AACX,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG9C,qBAAqB;AACrB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG3E,wBAAwB;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAEjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AAGtF,2BAA2B;AAC3B,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,wCAAwC,CAAC;AAEhD,uBAAuB;AACvB,OAAO,EACL,qBAAqB,GACtB,MAAM,sCAAsC,CAAC;AAM9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE1E,cAAc;AACd,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC","sourcesContent":["\"use client\";\n\n// Query Client factory (client-only; requires @tanstack/react-query)\nexport { createQueryClient } from '../query-client.js';\nexport type { CreateQueryClientOptions } from '../query-client.js';\n\n// Provider\nexport { QueryProvider } from './provider.js';\nexport type { QueryProviderProps } from './provider.js';\n\n// Firestore Provider\nexport { FirestoreProvider, useFirestoreDb } from './firestore/context.js';\nexport type { FirestoreProviderProps } from './firestore/context.js';\n\n// Firestore Query Hooks\nexport { useFirestoreDoc } from './firestore/use-firestore-doc.js';\nexport { useFirestoreCollection } from './firestore/use-firestore-collection.js';\nexport type { FirestoreSourceState, WithSourceState, BatchFirestoreDocOutcome } from '../firestore/types.js';\nexport { useFirestoreInfinite } from './firestore/use-firestore-infinite.js';\nexport { useFirestorePaginated } from './firestore/use-firestore-paginated.js';\nexport type { UseFirestorePaginatedResult } from './firestore/use-firestore-paginated.js';\nexport { useFirestoreCount } from './firestore/use-firestore-count.js';\nexport { useFirestoreLiveInfinite } from './firestore/use-firestore-live-infinite.js';\nexport type { FirestoreLiveInfiniteResult } from './firestore/use-firestore-live-infinite.js';\n\n// Firestore Mutation Hooks\nexport {\n  useFirestoreSet,\n  useFirestoreUpdate,\n  useFirestoreDelete,\n  useFirestoreBatch,\n} from './firestore/use-firestore-mutations.js';\n\n// Batch Firestore Docs\nexport {\n  useBatchFirestoreDocs,\n} from './firestore/useBatchFirestoreDocs.js';\nexport type {\n  BatchFirestoreDocsOptions,\n  BatchFirestoreDocsResult,\n  BatchFirestoreDocsTransport,\n} from './firestore/useBatchFirestoreDocs.js';\nexport { ABSENT_RETRY_DELAYS_MS } from './firestore/absence-scheduler.js';\n\n// Search Hook\nexport { useFirestoreSearch } from './search/use-firestore-search.js';\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ttt-productions/query-core",
-    "version": "0.14.4",
+    "version": "0.14.6",
     "description": "Shared TanStack Query (React Query) client defaults, query key helpers, and Firestore integration hooks for TTT Productions apps",
     "repository": {
         "type": "git",
@@ -63,10 +63,9 @@
         "@tanstack/react-query": "^5.0.0",
         "@types/react": "^19.0.0",
         "@types/react-dom": "^19.0.0",
-        "firebase": "^11.0.0",
+        "firebase": "^12.14.0",
         "react": "^19.2.0",
-        "react-dom": "^19.2.0",
-        "typescript": "^5.8.3"
+        "react-dom": "^19.2.0"
     },
     "author": "DJ (TTT Productions)",
     "license": "MIT"