@sanity/sdk 0.0.0-alpha.25 → 0.0.0-alpha.26

package/dist/index.d.ts

@@ -20,8 +20,8 @@ import {PatchMutation} from '@sanity/mutate/_unstable_store'
 import {PatchOperations} from '@sanity/types'
 import {PathSegment} from '@sanity/types'
 import {PreviewStoreState as PreviewStoreState_2} from './previewStore'
-import {ProjectionStoreState} from './projectionStore'
-import {ProjectionValuePending as ProjectionValuePending_2} from './projectionStore'
+import {ProjectionStoreState} from './types'
+import {ProjectionValuePending as ProjectionValuePending_2} from './types'
 import {ResponseQueryOptions} from '@sanity/client'
 import {Role} from '@sanity/types'
 import {SanityClient} from '@sanity/client'
@@ -1649,7 +1649,8 @@ declare interface ProjectionNode extends BaseNode {
 }
 
 /**
- * @beta
+ * @public
+ * The result of a projection query
  */
 export declare interface ProjectionValuePending<TValue extends object> {
   data: TValue | null
@@ -2201,7 +2202,7 @@ declare interface UsersStoreState {
 }
 
 /**
- * @beta
+ * @public
  */
 export declare type ValidProjection = `{${string}}`
 

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createClient } from "@sanity/client";
-import { Observable, share, map, distinctUntilChanged, skip, filter, switchMap, interval, takeWhile, fromEvent, EMPTY, defer, firstValueFrom, from, asapScheduler, concatMap, of, withLatestFrom, concat, timer, throwError, first as first$1, Subject, takeUntil, partition, merge, shareReplay, tap as tap$1, catchError as catchError$1, startWith as startWith$1, pairwise as pairwise$1, groupBy as groupBy$1, mergeMap as mergeMap$1, throttle, race, NEVER, combineLatest, debounceTime } from "rxjs";
+import { Observable, share, map, distinctUntilChanged, skip, filter, exhaustMap, timer, from, takeWhile, switchMap, firstValueFrom, fromEvent, EMPTY, defer, asapScheduler, concatMap, of, withLatestFrom, concat, throwError, first as first$1, Subject, takeUntil, partition, merge, shareReplay, tap as tap$1, catchError as catchError$1, startWith as startWith$1, pairwise as pairwise$1, groupBy as groupBy$1, mergeMap as mergeMap$1, throttle, race, NEVER, combineLatest, debounceTime, Subscription } from "rxjs";
 import { devtools } from "zustand/middleware";
 import { createStore } from "zustand/vanilla";
 import { pick, isEqual, omit, isObject } from "lodash-es";
@@ -161,42 +161,112 @@ function createStateSourceAction(options) {
   }
   return stateSourceAction;
 }
-const DEFAULT_BASE = "http://localhost", AUTH_CODE_PARAM = "sid", DEFAULT_API_VERSION$1 = "2021-06-07", REQUEST_TAG_PREFIX = "sanity.sdk.auth", refreshStampedToken = ({ state }) => {
-  const { clientFactory, apiHost, storageArea, storageKey } = state.get().options, refreshInterval = 12 * 60 * 60 * 1e3;
+const DEFAULT_BASE = "http://localhost", AUTH_CODE_PARAM = "sid", DEFAULT_API_VERSION$1 = "2021-06-07", REQUEST_TAG_PREFIX = "sanity.sdk.auth", REFRESH_INTERVAL = 12 * 60 * 60 * 1e3, LOCK_NAME = "sanity-token-refresh-lock";
+function getLastRefreshTime(storageArea, storageKey) {
+  try {
+    const data = storageArea?.getItem(`${storageKey}_last_refresh`);
+    return data ? parseInt(data, 10) : 0;
+  } catch {
+    return 0;
+  }
+}
+function setLastRefreshTime(storageArea, storageKey) {
+  try {
+    storageArea?.setItem(`${storageKey}_last_refresh`, Date.now().toString());
+  } catch {
+  }
+}
+function getNextRefreshDelay(storageArea, storageKey) {
+  const lastRefresh = getLastRefreshTime(storageArea, storageKey);
+  if (!lastRefresh) return 0;
+  const now = Date.now(), nextRefreshTime = lastRefresh + REFRESH_INTERVAL;
+  return Math.max(0, nextRefreshTime - now);
+}
+function createTokenRefreshStream(token, clientFactory, apiHost) {
+  return new Observable((subscriber) => {
+    const subscription = clientFactory({
+      apiVersion: DEFAULT_API_VERSION$1,
+      requestTagPrefix: "sdk.token-refresh",
+      useProjectHostname: !1,
+      token,
+      ignoreBrowserTokenWarning: !0,
+      ...apiHost && { apiHost }
+    }).observable.request({
+      uri: "auth/refresh-token",
+      method: "POST",
+      body: {
+        token
+      }
+    }).subscribe(subscriber);
+    return () => subscription.unsubscribe();
+  });
+}
+async function acquireTokenRefreshLock(refreshFn, storageArea, storageKey) {
+  if (!navigator.locks)
+    return console.warn("Web Locks API not supported. Proceeding with uncoordinated refresh."), await refreshFn(), setLastRefreshTime(storageArea, storageKey), !0;
+  try {
+    return await navigator.locks.request(LOCK_NAME, { mode: "exclusive" }, async (lock) => {
+      if (!lock) return !1;
+      for (; ; ) {
+        const delay2 = getNextRefreshDelay(storageArea, storageKey);
+        delay2 > 0 && await new Promise((resolve) => setTimeout(resolve, delay2));
+        try {
+          await refreshFn(), setLastRefreshTime(storageArea, storageKey);
+        } catch (error) {
+          console.error("Token refresh failed within lock:", error);
+        }
+        await new Promise((resolve) => setTimeout(resolve, REFRESH_INTERVAL));
+      }
+    }) === !0;
+  } catch (error) {
+    return console.error("Failed to request token refresh lock:", error), !1;
+  }
+}
+const refreshStampedToken = ({ state }) => {
+  const { clientFactory, apiHost, storageArea, storageKey } = state.get().options;
   return state.observable.pipe(
-    map(({ authState }) => authState),
+    map((storeState) => ({
+      authState: storeState.authState,
+      dashboardContext: storeState.dashboardContext
+    })),
     filter(
-      (authState) => authState.type === AuthStateType.LOGGED_IN
+      (storeState) => storeState.authState.type === AuthStateType.LOGGED_IN
     ),
-    distinctUntilChanged(),
-    filter((authState) => authState.token.includes("-st")),
+    distinctUntilChanged(
+      (prev, curr) => prev.authState.type === curr.authState.type && prev.authState.token === curr.authState.token && // Only care about token for distinctness here
+      prev.dashboardContext === curr.dashboardContext
+    ),
+    // Make distinctness check explicit
+    filter((storeState) => storeState.authState.token.includes("-st")),
     // Ensure we only try to refresh stamped tokens
-    switchMap(
-      (authState) => interval(refreshInterval).pipe(
+    exhaustMap((storeState) => {
+      const performRefresh = async () => {
+        const currentState = state.get();
+        if (currentState.authState.type !== AuthStateType.LOGGED_IN)
+          throw new Error("User logged out before refresh could complete");
+        const currentToken = currentState.authState.token, response = await firstValueFrom(
+          createTokenRefreshStream(currentToken, clientFactory, apiHost)
+        );
+        state.set("setRefreshStampedToken", (prev) => ({
+          authState: prev.authState.type === AuthStateType.LOGGED_IN ? { ...prev.authState, token: response.token } : prev.authState
+        })), storageArea?.setItem(storageKey, JSON.stringify({ token: response.token }));
+      };
+      return storeState.dashboardContext ? timer(REFRESH_INTERVAL, REFRESH_INTERVAL).pipe(
+        // Check if still logged in before each refresh attempt in the timer
         takeWhile(() => state.get().authState.type === AuthStateType.LOGGED_IN),
-        map(() => authState.token),
-        distinctUntilChanged(),
-        map(
-          (token) => clientFactory({
-            apiVersion: DEFAULT_API_VERSION$1,
-            requestTagPrefix: "sdk.token-refresh",
-            useProjectHostname: !1,
-            token,
-            ignoreBrowserTokenWarning: !0,
-            ...apiHost && { apiHost }
-          })
-        ),
+        // Use switchMap here: if the timer ticks again, we *do* want the latest token request
         switchMap(
-          (client) => client.observable.request({
-            uri: "auth/refresh-token",
-            method: "POST",
-            body: {
-              token: authState.token
-            }
-          })
-        )
-      )
-    )
+          () => createTokenRefreshStream(storeState.authState.token, clientFactory, apiHost)
+        ),
+        // Map the successful response for the outer subscribe block
+        map((response) => ({ token: response.token }))
+      ) : from(acquireTokenRefreshLock(performRefresh, storageArea, storageKey)).pipe(
+        filter((hasLock) => hasLock),
+        // If acquireTokenRefreshLock *does* somehow resolve true (e.g., locks unsupported),
+        // emit the token that triggered this exhaustMap execution.
+        map(() => ({ token: storeState.authState.token }))
+      );
+    })
   ).subscribe({
     next: (response) => {
       state.set("setRefreshStampedToken", (prev) => ({
@@ -244,7 +314,17 @@ const DEFAULT_BASE = "http://localhost", AUTH_CODE_PARAM = "sid", DEFAULT_API_VE
   });
 };
 function getAuthCode(callbackUrl, locationHref) {
-  const loc = new URL(locationHref, DEFAULT_BASE), callbackLocation = callbackUrl ? new URL(callbackUrl, DEFAULT_BASE) : void 0, callbackLocationMatches = callbackLocation ? loc.pathname.toLowerCase().startsWith(callbackLocation.pathname.toLowerCase()) : !0, authCode = new URLSearchParams(loc.hash.slice(1)).get(AUTH_CODE_PARAM) || new URLSearchParams(loc.search).get(AUTH_CODE_PARAM);
+  const loc = new URL(locationHref, DEFAULT_BASE), callbackLocation = callbackUrl ? new URL(callbackUrl, DEFAULT_BASE) : void 0, callbackLocationMatches = callbackLocation ? loc.pathname.toLowerCase().startsWith(callbackLocation.pathname.toLowerCase()) : !0;
+  let authCode = new URLSearchParams(loc.hash.slice(1)).get(AUTH_CODE_PARAM) || new URLSearchParams(loc.search).get(AUTH_CODE_PARAM);
+  if (!authCode) {
+    const contextParam = new URLSearchParams(loc.search).get("_context");
+    if (contextParam)
+      try {
+        const parsedContext = JSON.parse(contextParam);
+        parsedContext && typeof parsedContext == "object" && typeof parsedContext.sid == "string" && parsedContext.sid && (authCode = parsedContext.sid);
+      } catch {
+      }
+  }
   return authCode && callbackLocationMatches ? authCode : null;
 }
 function getTokenFromStorage(storageArea, storageKey) {
@@ -277,6 +357,10 @@ function getDefaultLocation() {
     return DEFAULT_BASE;
   }
 }
+function getCleanedUrl(locationUrl) {
+  const loc = new URL(locationUrl);
+  return loc.hash = "", loc.searchParams.delete("sid"), loc.searchParams.delete("url"), loc.toString();
+}
 const subscribeToStorageEventsAndSetToken = ({
   state
 }) => {
@@ -303,20 +387,33 @@ const authStore = {
       providers: customProviders,
       token: providedToken,
       clientFactory = createClient,
-      initialLocationHref = getDefaultLocation(),
-      storageArea = getDefaultStorage()
-    } = instance.config.auth ?? {}, storageKey = "__sanity_auth_token";
+      initialLocationHref = getDefaultLocation()
+    } = instance.config.auth ?? {};
+    let storageArea = instance.config.auth?.storageArea;
+    const storageKey = "__sanity_auth_token";
     let loginDomain = "https://www.sanity.io";
     try {
       apiHost && new URL(apiHost).hostname.endsWith(".sanity.work") && (loginDomain = "https://www.sanity.work");
     } catch {
     }
     const loginUrl = new URL("/login", loginDomain);
-    loginUrl.searchParams.set("origin", initialLocationHref), loginUrl.searchParams.set("type", "stampedToken"), loginUrl.searchParams.set("withSid", "true");
-    let authState;
+    loginUrl.searchParams.set("origin", getCleanedUrl(initialLocationHref)), loginUrl.searchParams.set("type", "stampedToken"), loginUrl.searchParams.set("withSid", "true");
+    let dashboardContext = {}, isInDashboard = !1;
+    try {
+      const contextParam = new URL(initialLocationHref).searchParams.get("_context");
+      if (contextParam) {
+        const parsedContext = JSON.parse(contextParam);
+        parsedContext && typeof parsedContext == "object" && Object.keys(parsedContext).length > 0 && (delete parsedContext.sid, dashboardContext = parsedContext, isInDashboard = !0);
+      }
+    } catch (err) {
+      console.error("Failed to parse dashboard context from initial location:", err);
+    }
+    isInDashboard || (storageArea = storageArea ?? getDefaultStorage());
     const token = getTokenFromStorage(storageArea, storageKey);
-    return providedToken ? authState = { type: AuthStateType.LOGGED_IN, token: providedToken, currentUser: null } : getAuthCode(callbackUrl, initialLocationHref) ? authState = { type: AuthStateType.LOGGING_IN, isExchangingToken: !1 } : token ? authState = { type: AuthStateType.LOGGED_IN, token, currentUser: null } : authState = { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }, {
+    let authState;
+    return providedToken ? authState = { type: AuthStateType.LOGGED_IN, token: providedToken, currentUser: null } : getAuthCode(callbackUrl, initialLocationHref) ? authState = { type: AuthStateType.LOGGING_IN, isExchangingToken: !1 } : token && !isInDashboard ? authState = { type: AuthStateType.LOGGED_IN, token, currentUser: null } : authState = { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }, {
       authState,
+      dashboardContext,
       options: {
         apiHost,
         loginUrl: loginUrl.toString(),
@@ -365,18 +462,20 @@ const authStore = {
     if (authState.type === AuthStateType.LOGGING_IN && authState.isExchangingToken) return !1;
     const authCode = getAuthCode(callbackUrl, locationHref);
     if (!authCode) return !1;
-    const parsedUrl = new URL(locationHref);
+    const cleanedUrl = getCleanedUrl(locationHref), parsedUrl = new URL(locationHref);
     let dashboardContext = {};
     try {
-      const contextParam = parsedUrl.searchParams.get("_context") ?? "{}";
-      dashboardContext = JSON.parse(contextParam);
+      const contextParam = parsedUrl.searchParams.get("_context");
+      if (contextParam) {
+        const parsedContext = JSON.parse(contextParam);
+        parsedContext && typeof parsedContext == "object" && (delete parsedContext.sid, dashboardContext = parsedContext);
+      }
     } catch (err) {
       console.error("Failed to parse dashboard context:", err);
     }
-    const { mode, env, orgId } = dashboardContext;
     state.set("exchangeSessionForToken", {
       authState: { type: AuthStateType.LOGGING_IN, isExchangingToken: !0 },
-      dashboardContext: { mode, env, orgId }
+      dashboardContext
     });
     try {
       const client = clientFactory({
@@ -390,11 +489,9 @@ const authStore = {
         query: { sid: authCode },
         tag: "fetch-token"
       });
-      storageArea?.setItem(storageKey, JSON.stringify({ token })), state.set("setToken", { authState: { type: AuthStateType.LOGGED_IN, token, currentUser: null } });
-      const loc = new URL(locationHref);
-      return loc.hash = "", loc.searchParams.delete("sid"), loc.searchParams.delete("url"), loc.toString();
+      return storageArea?.setItem(storageKey, JSON.stringify({ token })), state.set("setToken", { authState: { type: AuthStateType.LOGGED_IN, token, currentUser: null } }), cleanedUrl;
     } catch (error) {
-      return state.set("exchangeSessionForTokenError", { authState: { type: AuthStateType.ERROR, error } }), !1;
+      return state.set("exchangeSessionForTokenError", { authState: { type: AuthStateType.ERROR, error } }), cleanedUrl;
     }
   }
 ), logout = bindActionGlobally(authStore, async ({ state }) => {
@@ -416,7 +513,7 @@ const authStore = {
   } finally {
     state.set("logoutSuccess", {
       authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
-    }), storageArea?.removeItem(storageKey);
+    }), storageArea?.removeItem(storageKey), storageArea?.removeItem(`${storageKey}_last_refresh`);
   }
 }), DEFAULT_API_VERSION = "2024-11-12", DEFAULT_REQUEST_TAG_PREFIX = "sanity.sdk", allowedKeys = Object.keys({
   apiHost: null,
@@ -4593,25 +4690,19 @@ const _getPreviewState = bindActionByDataset(
       )
     );
   }
-}), getProjectState = project.getState, resolveProject = project.resolveState, PROJECTION_TAG = "sdk.projection", PROJECTION_PERSPECTIVE = "drafts", PROJECTION_STATE_CLEAR_DELAY = 1e3, STABLE_EMPTY_PROJECTION = {
-  data: null,
-  isPending: !1
-};
-function validateProjection(projection) {
-  if (!projection.startsWith("{") || !projection.endsWith("}"))
-    throw new Error(
-      `Invalid projection format: "${projection}". Projections must be enclosed in curly braces, e.g. "{title, 'author': author.name}"`
-    );
-  return projection;
-}
+}), getProjectState = project.getState, resolveProject = project.resolveState;
 function createProjectionQuery(documentIds, documentProjections) {
-  const projections = Array.from(documentIds).filter((id) => documentProjections[id]).map((id) => {
-    const projection = validateProjection(documentProjections[id]), projectionHash = hashString(projection);
-    return { documentId: id, projection, projectionHash };
+  const projections = Array.from(documentIds).flatMap((id) => {
+    const projectionsForDoc = documentProjections[id];
+    return projectionsForDoc ? Object.entries(projectionsForDoc).map(([projectionHash, projection]) => ({
+      documentId: id,
+      projection,
+      projectionHash
+    })) : [];
   }).reduce((acc, { documentId, projection, projectionHash }) => {
     const obj = acc[projectionHash] ?? { documentIds: /* @__PURE__ */ new Set(), projection };
     return obj.documentIds.add(documentId), acc[projectionHash] = obj, acc;
-  }, {}), query = `[${Object.entries(projections).map(([projectionHash, { projection }]) => `...*[_id in $__ids_${projectionHash}]{_id,_type,_updatedAt,"result":{...${projection}}}`).join(",")}]`, params = Object.fromEntries(
+  }, {}), query = `[${Object.entries(projections).map(([projectionHash, { projection }]) => `...*[_id in $__ids_${projectionHash}]{_id,_type,_updatedAt,"__projectionHash":"${projectionHash}","result":{...${projection}}}`).join(",")}]`, params = Object.fromEntries(
     Object.entries(projections).map(([projectionHash, value]) => {
       const idsInProjection = Array.from(value.documentIds).flatMap((id) => [
         getPublishedId(id),
@@ -4623,50 +4714,83 @@ function createProjectionQuery(documentIds, documentProjections) {
   return { query, params };
 }
 function processProjectionQuery({ ids, results }) {
-  const resultMap = results.reduce(
-    (acc, next) => (acc[next._id] = next, acc),
-    {}
-  );
-  return Object.fromEntries(
-    Array.from(ids).map((id) => {
-      const publishedId = getPublishedId(id), draftId = getDraftId(id), draftResult = resultMap[draftId], publishedResult = resultMap[publishedId], projectionResult = draftResult?.result ?? publishedResult?.result;
-      if (!projectionResult) return [id, { data: null, isPending: !1 }];
-      const status = {
-        ...draftResult?._updatedAt && { lastEditedDraftAt: draftResult._updatedAt },
-        ...publishedResult?._updatedAt && { lastEditedPublishedAt: publishedResult._updatedAt }
-      };
-      return [id, { data: { ...projectionResult, status }, isPending: !1 }];
-    })
-  );
+  const groupedResults = {};
+  for (const result of results) {
+    const originalId = getPublishedId(result._id), hash = result.__projectionHash, isDraft = result._id.startsWith("drafts.");
+    ids.has(originalId) && (groupedResults[originalId] || (groupedResults[originalId] = {}), groupedResults[originalId][hash] || (groupedResults[originalId][hash] = {}), isDraft ? groupedResults[originalId][hash].draft = result : groupedResults[originalId][hash].published = result);
+  }
+  const finalValues = {};
+  for (const originalId of ids) {
+    finalValues[originalId] = {};
+    const projectionsForDoc = groupedResults[originalId];
+    if (projectionsForDoc)
+      for (const hash in projectionsForDoc) {
+        const { draft, published } = projectionsForDoc[hash], projectionResultData = draft?.result ?? published?.result;
+        if (!projectionResultData) {
+          finalValues[originalId][hash] = { data: null, isPending: !1 };
+          continue;
+        }
+        const status = {
+          ...draft?._updatedAt && { lastEditedDraftAt: draft._updatedAt },
+          ...published?._updatedAt && { lastEditedPublishedAt: published._updatedAt }
+        };
+        finalValues[originalId][hash] = {
+          data: { ...projectionResultData, status },
+          isPending: !1
+        };
+      }
+  }
+  return finalValues;
+}
+const PROJECTION_TAG = "sdk.projection", PROJECTION_PERSPECTIVE = "drafts", PROJECTION_STATE_CLEAR_DELAY = 1e3, STABLE_EMPTY_PROJECTION = {
+  data: null,
+  isPending: !1
+};
+function validateProjection(projection) {
+  if (!projection.startsWith("{") || !projection.endsWith("}"))
+    throw new Error(
+      `Invalid projection format: "${projection}". Projections must be enclosed in curly braces, e.g. "{title, 'author': author.name}"`
+    );
+  return projection;
 }
 const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a2, b2) => a2.size === b2.size && Array.from(a2).every((i2) => b2.has(i2)), subscribeToStateAndFetchBatches = ({
   state,
   instance
 }) => {
   const documentProjections$ = state.observable.pipe(
-    map((i2) => i2.documentProjections),
-    distinctUntilChanged()
-  ), newSubscriberIds$ = state.observable.pipe(
+    map((s2) => s2.documentProjections),
+    distinctUntilChanged(isEqual)
+  ), activeDocumentIds$ = state.observable.pipe(
     map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
-    distinctUntilChanged(isSetEqual),
+    distinctUntilChanged(isSetEqual)
+  ), pendingUpdateSubscription = activeDocumentIds$.pipe(
     debounceTime(BATCH_DEBOUNCE_TIME),
     startWith$1(/* @__PURE__ */ new Set()),
     pairwise$1(),
     tap$1(([prevIds, currIds]) => {
-      const newIds = [...currIds].filter((element) => !prevIds.has(element));
-      state.set("updatingPending", (prev) => {
-        const pendingValues = newIds.reduce((acc, id) => {
-          const prevValue = prev.values[id], value = prevValue?.data ? prevValue.data : null;
-          return acc[id] = { data: value, isPending: !0 }, acc;
-        }, {});
-        return { values: { ...prev.values, ...pendingValues } };
+      const newIds = [...currIds].filter((id) => !prevIds.has(id));
+      newIds.length !== 0 && state.set("updatingPending", (prev) => {
+        const nextValues = { ...prev.values };
+        for (const id of newIds) {
+          const projectionsForDoc = prev.documentProjections[id];
+          if (!projectionsForDoc) continue;
+          const updatedValuesForDoc = { ...prev.values[id] ?? {} };
+          for (const hash in projectionsForDoc) {
+            const currentValue = updatedValuesForDoc[hash];
+            updatedValuesForDoc[hash] = {
+              data: currentValue?.data ?? null,
+              isPending: !0
+            };
+          }
+          nextValues[id] = updatedValuesForDoc;
+        }
+        return { values: nextValues };
       });
-    }),
-    map(([, ids]) => ids),
-    distinctUntilChanged(isSetEqual)
-  );
-  return combineLatest([newSubscriberIds$, documentProjections$]).pipe(
-    distinctUntilChanged(isEqual),
+    })
+  ).subscribe(), queryExecutionSubscription = combineLatest([activeDocumentIds$, documentProjections$]).pipe(
+    debounceTime(BATCH_DEBOUNCE_TIME),
+    distinctUntilChanged(isEqual)
+  ).pipe(
     switchMap(([ids, documentProjections]) => {
       if (!ids.size) return EMPTY;
       const { query, params } = createProjectionQuery(ids, documentProjections), controller = new AbortController();
@@ -4688,19 +4812,31 @@ const BATCH_DEBOUNCE_TIME = 50, isSetEqual = (a2, b2) => a2.size === b2.size &&
         };
       }).pipe(map((data) => ({ data, ids })));
     }),
-    map(({ ids, data }) => ({
-      values: processProjectionQuery({
+    map(
+      ({ ids, data }) => processProjectionQuery({
         ids,
         results: data
       })
-    }))
+    )
   ).subscribe({
-    next: ({ values }) => {
-      state.set("updateResult", (prev) => ({
-        values: { ...prev.values, ...values }
-      }));
+    next: (processedValues) => {
+      state.set("updateResult", (prev) => {
+        const nextValues = { ...prev.values };
+        for (const docId in processedValues)
+          processedValues[docId] && (nextValues[docId] = {
+            ...prev.values[docId] ?? {},
+            ...processedValues[docId]
+          });
+        return { values: nextValues };
+      });
+    },
+    error: (err) => {
+      console.error("Error fetching projection batches:", err);
     }
   });
+  return new Subscription(() => {
+    pendingUpdateSubscription.unsubscribe(), queryExecutionSubscription.unsubscribe();
+  });
 }, projectionStore = {
   name: "Projection",
   getInitialState() {
@@ -4721,28 +4857,53 @@ function getProjectionState(...args) {
 const _getProjectionState = bindActionByDataset(
   projectionStore,
   createStateSourceAction({
-    selector: ({ state }, options) => state.values[options.documentId] ?? STABLE_EMPTY_PROJECTION,
+    selector: ({ state }, options) => {
+      const documentId = getPublishedId(options.documentId), projectionHash = hashString(options.projection);
+      return state.values[documentId]?.[projectionHash] ?? STABLE_EMPTY_PROJECTION;
+    },
     onSubscribe: ({ state }, { projection, ...docHandle }) => {
-      const subscriptionId = insecureRandomId(), documentId = getPublishedId(docHandle.documentId);
+      const subscriptionId = insecureRandomId(), documentId = getPublishedId(docHandle.documentId), validProjection = validateProjection(projection), projectionHash = hashString(validProjection);
       return state.set("addSubscription", (prev) => ({
         documentProjections: {
           ...prev.documentProjections,
-          [documentId]: validateProjection(projection)
+          [documentId]: {
+            ...prev.documentProjections[documentId],
+            [projectionHash]: validProjection
+          }
         },
         subscriptions: {
           ...prev.subscriptions,
           [documentId]: {
             ...prev.subscriptions[documentId],
-            [subscriptionId]: !0
+            [projectionHash]: {
+              ...prev.subscriptions[documentId]?.[projectionHash],
+              [subscriptionId]: !0
+            }
           }
         }
       })), () => {
         setTimeout(() => {
           state.set("removeSubscription", (prev) => {
-            const documentSubscriptions = omit(prev.subscriptions[documentId], subscriptionId), hasSubscribers = !!Object.keys(documentSubscriptions).length, prevValue = prev.values[documentId], projectionValue = prevValue?.data ? prevValue.data : null;
-            return {
-              subscriptions: hasSubscribers ? { ...prev.subscriptions, [documentId]: documentSubscriptions } : omit(prev.subscriptions, documentId),
-              values: hasSubscribers ? prev.values : { ...prev.values, [documentId]: { data: projectionValue, isPending: !1 } }
+            const documentSubscriptionsForHash = omit(
+              prev.subscriptions[documentId]?.[projectionHash],
+              subscriptionId
+            ), hasSubscribersForProjection = !!Object.keys(documentSubscriptionsForHash).length, nextSubscriptions = { ...prev.subscriptions }, nextDocumentProjections = { ...prev.documentProjections }, nextValues = { ...prev.values };
+            if (hasSubscribersForProjection)
+              nextSubscriptions[documentId] && (nextSubscriptions[documentId][projectionHash] = documentSubscriptionsForHash);
+            else {
+              delete nextSubscriptions[documentId][projectionHash], delete nextDocumentProjections[documentId][projectionHash];
+              const currentProjectionValue = prev.values[documentId]?.[projectionHash];
+              currentProjectionValue && nextValues[documentId] && (nextValues[documentId][projectionHash] = {
+                data: currentProjectionValue.data,
+                isPending: !1
+              });
+            }
+            return Object.values(
+              nextSubscriptions[documentId] ?? {}
+            ).some((subs) => Object.keys(subs).length > 0) || (delete nextSubscriptions[documentId], delete nextDocumentProjections[documentId]), {
+              subscriptions: nextSubscriptions,
+              documentProjections: nextDocumentProjections,
+              values: nextValues
             };
           });
         }, PROJECTION_STATE_CLEAR_DELAY);
@@ -4931,7 +5092,7 @@ function createGroqSearchFilter(query) {
     `${finalIncrementalToken}${WILDCARD_TOKEN}`
   ), `[@] match text::query("${processedTokens.join(" ").replace(/"/g, '\\"')}")`;
 }
-var version = "0.0.0-alpha.25";
+var version = "0.0.0-alpha.26";
 const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`;
 export {
   AuthStateType,