@sanity/sdk 2.18.0 → 2.19.0

package/dist/index.js

@@ -1,34 +1,36 @@
-import { switchMap, from, firstValueFrom, EMPTY, asapScheduler, distinctUntilChanged, map as map$1, combineLatest, of, concatMap, withLatestFrom, filter as filter$1, concat, timer, throwError, defer, Observable, first as first$1, Subject, takeUntil, share, 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, retry, throttle, race, skip, NEVER, fromEvent, Subscription, debounceTime } from "rxjs";
+import { CorsOriginError } from "@sanity/client";
+import { switchMap, from, firstValueFrom, EMPTY, asapScheduler, distinctUntilChanged, map as map$1, combineLatest, of, concatMap, withLatestFrom, filter as filter$1, concat, timer, throwError, defer, Observable, first as first$1, Subject, takeUntil, share, 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, retry, throttle, race, skip, NEVER, fromEvent, Subscription, auditTime, debounceTime } from "rxjs";
 import { createLogger, pickProperties, insecureRandomId, getClientState, bindActionGlobally, createStateSourceAction, setCleanupTimeout, omitProperty, defineStore, authStore, getAuthLogger, AuthStateType, getCleanedUrl, getTokenFromLocation, createLoggedInAuthState, getAuthCode, REQUEST_TAG_PREFIX, DEFAULT_API_VERSION, getDefaultLocation, isDeepEqual, configureLogging as configureLogging$1, isReleasePerspective, bindActionByResource, isDatasetResource, isMediaLibraryResource, isCanvasResource, getCurrentUserState, getUsersKey, addSubscription, USERS_STATE_CLEAR_DELAY, removeSubscription, parseUsersKey, getClient, PROJECT_API_VERSION, setUsersError, setUsersData, API_VERSION as API_VERSION$8, getDashboardOrganizationId as getDashboardOrganizationId$1, updateLastLoadMoreRequest, cancelRequest, initializeRequest, getTokenState, getQueryState, resolveQuery, bindActionByResourceAndPerspective, PREVIEW_PROJECTION, transformProjectionToPreview } from "./_chunks-es/createGroqSearchFilter.js";
-import { createGroqSearchFilter, getActiveReleasesState, getAllReleasesState, getAuthState, getClientErrorApiBody, getClientErrorApiDescription, getClientErrorApiType, getIsInDashboardState, getLoginUrlState, getPerspectiveState, getQueryKey, isCanvasSource, isDatasetSource, isMediaLibrarySource, isProjectUserNotFoundClientError, isStudioConfig, parseQueryKey, setAuthToken } from "./_chunks-es/createGroqSearchFilter.js";
-import { first, switchMap as switchMap$1, groupBy, mergeMap, startWith, pairwise, filter, map, delay, tap, catchError, scan, share as share$1 } from "rxjs/operators";
+import { CORE_SDK_VERSION, createGroqSearchFilter, getActiveReleasesState, getAllReleasesState, getAuthState, getClientErrorApiBody, getClientErrorApiDescription, getClientErrorApiType, getIsInDashboardState, getLoginUrlState, getPerspectiveState, getQueryKey, isCanvasSource, isDatasetSource, isMediaLibrarySource, isProjectUserNotFoundClientError, isStudioConfig, parseQueryKey, setAuthToken } from "./_chunks-es/createGroqSearchFilter.js";
+import "zustand/middleware";
+import "zustand/vanilla";
+import { first, switchMap as switchMap$1, groupBy, mergeMap, startWith, pairwise, filter, map, delay, tap, catchError, scan, retry as retry$1, distinctUntilChanged as distinctUntilChanged$1, share as share$1 } from "rxjs/operators";
 import { createController, createNode } from "@sanity/comlink";
 import { createSelector } from "reselect";
 import { SanityEncoder } from "@sanity/mutate";
-import { getVersionId, DocumentId, getPublishedId, getDraftId, isDraftId, isVersionId, isPublishedId } from "@sanity/id-utils";
+import { createDocumentLoaderFromClient } from "@sanity/mutate/_unstable_store";
+import { isKeySegment, isKeyedObject } from "@sanity/types";
+import "groq";
+import { getPublishedId, DocumentId, getVersionId, getDraftId, isDraftId, isVersionId, isPublishedId } from "@sanity/id-utils";
 import { jsonMatch, stringifyPath, slicePath, getIndexForKey } from "@sanity/json-match";
 import { getIndexForKey as getIndexForKey2, getPathDepth, joinPaths, jsonMatch as jsonMatch2, slicePath as slicePath2, stringifyPath as stringifyPath2 } from "@sanity/json-match";
 import { evaluateSync, parse } from "groq-js";
 import { applyPatches, parsePatch } from "@sanity/diff-match-patch";
-import { isKeySegment, isKeyedObject } from "@sanity/types";
 import { diffValue } from "@sanity/diff-patch";
-import { createDocumentLoaderFromClient } from "@sanity/mutate/_unstable_store";
 import { SDK_CHANNEL_NAME, SDK_NODE_NAME } from "@sanity/message-protocol";
 import { fromUrl } from "@sanity/bifur-client";
-import { CorsOriginError } from "@sanity/client";
-import { CORE_SDK_VERSION } from "./_chunks-es/version.js";
 function createSanityInstance(config = {}) {
   const instanceId = crypto.randomUUID(), disposeListeners = /* @__PURE__ */ new Map(), disposed = { current: !1 }, instanceContext = {
     instanceId,
     projectId: config.projectId,
     dataset: config.dataset
-  }, logger = createLogger("sdk", { instanceContext });
-  logger.info("Sanity instance created", {
+  }, logger2 = createLogger("sdk", { instanceContext });
+  logger2.info("Sanity instance created", {
     hasProjectId: !!config.projectId,
     hasDataset: !!config.dataset,
     hasAuth: !!config.auth,
     hasPerspective: !!config.perspective
-  }), logger.debug("Instance configuration", {
+  }), logger2.debug("Instance configuration", {
     projectId: config.projectId,
     dataset: config.dataset,
     perspective: config.perspective,
@@ -44,13 +46,13 @@ function createSanityInstance(config = {}) {
     isDisposed: () => disposed.current,
     dispose: () => {
       if (disposed.current) {
-        logger.trace("Dispose called on already disposed instance", { internal: !0 });
+        logger2.trace("Dispose called on already disposed instance", { internal: !0 });
         return;
       }
-      logger.trace("Disposing instance", {
+      logger2.trace("Disposing instance", {
         internal: !0,
         listenerCount: disposeListeners.size
-      }), disposed.current = !0, disposeListeners.forEach((listener) => listener()), disposeListeners.clear(), logger.info("Instance disposed");
+      }), disposed.current = !0, disposeListeners.forEach((listener) => listener()), disposeListeners.clear(), logger2.info("Instance disposed");
     },
     onDispose: (cb) => {
       const listenerId = insecureRandomId();
@@ -61,7 +63,7 @@ function createSanityInstance(config = {}) {
     getParent: () => {
     },
     createChild: (next) => {
-      logger.debug("Creating child instance", {
+      logger2.debug("Creating child instance", {
         parentInstanceId: instanceId.slice(0, 8),
         overridingProjectId: !!next.projectId,
         overridingDataset: !!next.dataset,
@@ -75,7 +77,7 @@ function createSanityInstance(config = {}) {
         }),
         { getParent: () => instance }
       );
-      return logger.trace("Child instance created", {
+      return logger2.trace("Child instance created", {
         internal: !0,
         childInstanceId: child.instanceId.slice(0, 8)
       }), child;
@@ -329,34 +331,34 @@ function observeOrganizationVerificationState(instance, projectIds) {
 const handleAuthCallback = bindActionGlobally(
   authStore,
   async ({ state, instance }, locationHref = getDefaultLocation()) => {
-    const logger = getAuthLogger(instance), { providedToken, callbackUrl, clientFactory, apiHost, storageArea, storageKey } = state.get().options;
+    const logger2 = getAuthLogger(instance), { providedToken, callbackUrl, clientFactory, apiHost, storageArea, storageKey } = state.get().options;
     if (providedToken)
-      return logger.debug("Skipping auth callback - token already provided"), !1;
+      return logger2.debug("Skipping auth callback - token already provided"), !1;
     const { authState } = state.get();
     if (authState.type === AuthStateType.LOGGING_IN && authState.isExchangingToken)
-      return logger.debug("Skipping auth callback - token exchange already in progress"), !1;
+      return logger2.debug("Skipping auth callback - token exchange already in progress"), !1;
     const cleanedUrl = getCleanedUrl(locationHref), tokenFromUrl = getTokenFromLocation(locationHref);
     if (tokenFromUrl)
-      return logger.info("Auth token found in URL, logging in"), state.set("setTokenFromUrl", {
+      return logger2.info("Auth token found in URL, logging in"), state.set("setTokenFromUrl", {
         authState: createLoggedInAuthState(tokenFromUrl, null)
       }), cleanedUrl;
     const authCode = getAuthCode(callbackUrl, locationHref);
     if (!authCode)
-      return logger.debug("No auth code found in callback URL"), !1;
+      return logger2.debug("No auth code found in callback URL"), !1;
     const parsedUrl = new URL(locationHref);
     let dashboardContext = {};
     try {
       const contextParam = parsedUrl.searchParams.get("_context");
       if (contextParam) {
         const parsedContext = JSON.parse(contextParam);
-        parsedContext && typeof parsedContext == "object" && (delete parsedContext.sid, dashboardContext = parsedContext, logger.debug("Dashboard context parsed from callback URL", {
+        parsedContext && typeof parsedContext == "object" && (delete parsedContext.sid, dashboardContext = parsedContext, logger2.debug("Dashboard context parsed from callback URL", {
           hasDashboardContext: !0
         }));
       }
     } catch (err) {
-      logger.warn("Failed to parse dashboard context from callback URL", { error: err });
+      logger2.warn("Failed to parse dashboard context from callback URL", { error: err });
     }
-    logger.info("Exchanging auth code for token"), state.set("exchangeSessionForToken", {
+    logger2.info("Exchanging auth code for token"), state.set("exchangeSessionForToken", {
       authState: { type: AuthStateType.LOGGING_IN, isExchangingToken: !0 },
       dashboardContext
     });
@@ -368,33 +370,33 @@ const handleAuthCallback = bindActionGlobally(
         useCdn: !1,
         ...apiHost && { apiHost }
       });
-      logger.debug("Fetching token from auth endpoint");
+      logger2.debug("Fetching token from auth endpoint");
       const { token } = await client.request({
         method: "GET",
         uri: "/auth/fetch",
         query: { sid: authCode },
         tag: "fetch-token"
       });
-      return logger.info("Auth token obtained successfully, user logged in"), storageArea?.setItem(storageKey, JSON.stringify({ token })), state.set("setToken", { authState: createLoggedInAuthState(token, null) }), cleanedUrl;
+      return logger2.info("Auth token obtained successfully, user logged in"), storageArea?.setItem(storageKey, JSON.stringify({ token })), state.set("setToken", { authState: createLoggedInAuthState(token, null) }), cleanedUrl;
     } catch (error) {
-      return logger.error("Failed to exchange auth code for token", { error }), state.set("exchangeSessionForTokenError", { authState: { type: AuthStateType.ERROR, error } }), cleanedUrl;
+      return logger2.error("Failed to exchange auth code for token", { error }), state.set("exchangeSessionForTokenError", { authState: { type: AuthStateType.ERROR, error } }), cleanedUrl;
     }
   }
 ), logout = bindActionGlobally(authStore, async ({ state, instance }) => {
-  const logger = getAuthLogger(instance), { clientFactory, apiHost, providedToken, storageArea, storageKey } = state.get().options;
+  const logger2 = getAuthLogger(instance), { clientFactory, apiHost, providedToken, storageArea, storageKey } = state.get().options;
   if (providedToken) {
-    logger.debug("Skipping logout - token is statically provided");
+    logger2.debug("Skipping logout - token is statically provided");
     return;
   }
   const { authState } = state.get();
   if (authState.type === AuthStateType.LOGGED_OUT && authState.isDestroyingSession) {
-    logger.debug("Skipping logout - already in progress");
+    logger2.debug("Skipping logout - already in progress");
     return;
   }
   const token = authState.type === AuthStateType.LOGGED_IN && authState.token;
   try {
     if (token) {
-      logger.info("Logging out user"), state.set("loggingOut", {
+      logger2.info("Logging out user"), state.set("loggingOut", {
         authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !0 }
       });
       const client = clientFactory({
@@ -405,13 +407,13 @@ const handleAuthCallback = bindActionGlobally(
         useProjectHostname: !1,
         useCdn: !1
       });
-      logger.debug("Calling logout endpoint"), await client.request({ uri: "/auth/logout", method: "POST", tag: "logout" });
+      logger2.debug("Calling logout endpoint"), await client.request({ uri: "/auth/logout", method: "POST", tag: "logout" });
     } else
-      logger.debug("No token to logout - already logged out");
+      logger2.debug("No token to logout - already logged out");
   } catch (error) {
-    throw logger.error("Logout request failed", { error }), error;
+    throw logger2.error("Logout request failed", { error }), error;
   } finally {
-    logger.info("User logged out, clearing stored tokens"), state.set("logoutSuccess", {
+    logger2.info("User logged out, clearing stored tokens"), state.set("logoutSuccess", {
       authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
     }), storageArea?.removeItem(storageKey), storageArea?.removeItem(`${storageKey}_last_refresh`);
   }
@@ -593,6 +595,9 @@ const API_VERSION$5 = "v2025-02-19", datasets = createFetcherStore({
     useProjectHostname: !0
   }).observable.pipe(switchMap((client) => client.observable.datasets.list()))
 }), getDatasetsState = datasets.getState, resolveDatasets = datasets.resolveState;
+function getEditingDocumentId(doc) {
+  return doc.liveEdit ? getPublishedId(DocumentId(doc.documentId)) : isReleasePerspective(doc.perspective) ? getVersionId(DocumentId(doc.documentId), doc.perspective.releaseName) : doc.perspective === "published" ? getPublishedId(DocumentId(doc.documentId)) : getDraftId(DocumentId(doc.documentId));
+}
 function getEffectiveDocumentId(doc) {
   return doc.liveEdit ? doc.documentId : isReleasePerspective(doc.perspective) ? getVersionId(DocumentId(doc.documentId), doc.perspective.releaseName) : getPublishedId(DocumentId(doc.documentId));
 }
@@ -3242,7 +3247,7 @@ const organizations = createFetcherStore({
     signal,
     ...options
   }))?.data[0]
-);
+), CONNECT_RETRY_MAX_DELAY = 1e3 * 240;
 function getBifurClient(client, token$) {
   const bifurVersionedClient = client.withConfig({ apiVersion: "2022-06-30" }), {
     resource,
@@ -3288,8 +3293,37 @@ const handleIncomingMessage = (event) => {
     default:
       throw new Error(`Got unknown presence event: ${JSON.stringify(event)}`);
   }
-}, createBifurTransport = (options) => {
-  const { client, token$, sessionId } = options, bifur = getBifurClient(client, token$), incomingEvents$ = bifur.listen("presence").pipe(map(handleIncomingMessage)), dispatchMessage = (message) => {
+}, createConnections = (bifur) => {
+  let generation = 0;
+  return defer(() => {
+    const current = ++generation;
+    return bifur.heartbeats.pipe(map(() => current));
+  }).pipe(
+    retry$1({
+      delay: (_error, retryCount) => timer(Math.min(CONNECT_RETRY_MAX_DELAY, 2 ** retryCount * 100)),
+      resetOnSuccess: !0
+    }),
+    // After `retry` so that one operator instance spans reconnects, making each
+    // live socket yield exactly one emission.
+    distinctUntilChanged$1(),
+    share$1()
+  );
+}, createIncomingEvents = (bifur, connections$) => connections$.pipe(
+  switchMap$1(
+    () => bifur.listen("presence").pipe(
+      // Let a dead listener go quietly. The next connection replaces it, and
+      // surfacing the error here would tear down the reconnect loop with it.
+      catchError(() => EMPTY)
+    )
+  ),
+  map(handleIncomingMessage),
+  share$1()
+), createUnload = () => typeof window > "u" ? EMPTY : merge(fromEvent(window, "beforeunload"), fromEvent(window, "pagehide")).pipe(
+  map(() => {
+  })
+), createBifurTransport = (options) => {
+  const { client, token$, sessionId } = options, bifur = getBifurClient(client, token$), connections$ = createConnections(bifur);
+  return [createIncomingEvents(bifur, connections$), (message) => {
     switch (message.type) {
       case "rollCall":
         return bifur.request("presence_rollcall", { session: sessionId });
@@ -3302,12 +3336,34 @@ const handleIncomingMessage = (event) => {
       default:
         return EMPTY;
     }
-  };
-  return typeof window < "u" && fromEvent(window, "beforeunload").pipe(switchMap$1(() => dispatchMessage({ type: "disconnect" }))).subscribe(), [incomingEvents$.pipe(share$1()), dispatchMessage];
-}, PRESENCE_API_VERSION = "2026-03-30", getInitialState = () => ({
+  }, connections$, createUnload()];
+};
+function isKeyedSegment(segment) {
+  return typeof segment == "object" && segment !== null && !Array.isArray(segment) && "_key" in segment;
+}
+function isEqualTuple(a, b) {
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function isEqualSegment(a, b) {
+  return a === b ? !0 : isKeyedSegment(a) && isKeyedSegment(b) ? a._key === b._key : Array.isArray(a) && Array.isArray(b) ? isEqualTuple(a, b) : !1;
+}
+function startsWithPath(prefix, candidate) {
+  return prefix.length > candidate.length ? !1 : prefix.every((segment, index) => isEqualSegment(segment, candidate[index]));
+}
+const logger = createLogger("presence"), PRESENCE_API_VERSION = "2026-03-30", REPORT_MIN_INTERVAL = 3e4, REPORT_AUDIT_TIME = 200, SESSION_TTL = 9e4, SWEEP_INTERVAL = 15e3, getInitialState = () => ({
   locations: /* @__PURE__ */ new Map(),
   users: {}
-}), presenceStore = defineStore({
+}), sendSafely = (dispatch2, message) => dispatch2(message).pipe(
+  catchError$1((error) => (logger.warn("Failed to send presence message", { messageType: message.type, error }), EMPTY))
+), asTrigger = (source$, name) => source$.pipe(
+  map$1(() => {
+  }),
+  catchError$1((error) => (logger.error("Presence announce trigger failed", { trigger: name, error }), EMPTY))
+), locationKey = ({ documentId, path, selection }) => JSON.stringify([documentId, path, selection ?? null]);
+function isEqualLocations(a, b) {
+  return a === b ? !0 : !a || !b || a.length !== b.length ? !1 : a.every((location, index) => locationKey(location) === locationKey(b[index]));
+}
+const presenceStore = defineStore({
   name: "presence",
   getInitialState,
   initialize: (context) => {
@@ -3326,97 +3382,223 @@ const handleIncomingMessage = (event) => {
     }) : getClient(instance, {
       apiVersion: PRESENCE_API_VERSION,
       resource
-    }), token$ = getTokenState(instance).observable.pipe(distinctUntilChanged()), [incomingEvents$, dispatch2] = createBifurTransport({
+    }), token$ = getTokenState(instance).observable.pipe(distinctUntilChanged()), [incomingEvents$, dispatch2, connections$, unload$] = createBifurTransport({
       client,
       token$,
       sessionId
     }), subscription = new Subscription();
-    if (subscription.add(
-      incomingEvents$.subscribe((event) => {
-        "sessionId" in event && event.sessionId === sessionId || (event.type === "state" ? state.set("presence/state", (prevState) => {
-          const newLocations = new Map(prevState.locations);
-          return newLocations.set(event.sessionId, {
-            userId: event.userId,
-            locations: event.locations
-          }), {
-            ...prevState,
-            locations: newLocations
-          };
-        }) : event.type === "disconnect" && state.set("presence/disconnect", (prevState) => {
+    subscription.add(
+      incomingEvents$.subscribe({
+        next: (event) => {
+          "sessionId" in event && event.sessionId === sessionId || (event.type === "state" ? state.set("presence/state", (prevState) => {
+            const newLocations = new Map(prevState.locations);
+            return newLocations.set(event.sessionId, {
+              userId: event.userId,
+              locations: event.locations,
+              lastSeenAt: Date.now()
+            }), {
+              ...prevState,
+              locations: newLocations
+            };
+          }) : event.type === "disconnect" && state.set("presence/disconnect", (prevState) => {
+            const newLocations = new Map(prevState.locations);
+            return newLocations.delete(event.sessionId), { ...prevState, locations: newLocations };
+          }));
+        },
+        // The transport re-establishes its listener on every live connection, so
+        // this should not fire. Handled rather than left to become an unhandled
+        // error, which is how presence used to die silently and for good.
+        error: (error) => {
+          logger.error("Presence event stream failed", { error });
+        }
+      })
+    ), subscription.add(
+      connections$.subscribe(() => {
+        state.set("presence/reset", (prevState) => ({
+          ...prevState,
+          locations: /* @__PURE__ */ new Map()
+        })), sendSafely(dispatch2, { type: "rollCall" }).subscribe();
+      })
+    ), subscription.add(
+      connections$.pipe(switchMap(() => timer(SWEEP_INTERVAL, SWEEP_INTERVAL))).subscribe(() => {
+        state.set("presence/expire", (prevState) => {
+          const cutoff = Date.now() - SESSION_TTL, stale = [...prevState.locations].filter(([, s]) => s.lastSeenAt < cutoff);
+          if (stale.length === 0) return prevState;
           const newLocations = new Map(prevState.locations);
-          return newLocations.delete(event.sessionId), { ...prevState, locations: newLocations };
+          for (const [staleSessionId] of stale) newLocations.delete(staleSessionId);
+          return { ...prevState, locations: newLocations };
+        });
+      })
+    ), subscription.add(
+      unload$.pipe(switchMap(() => sendSafely(dispatch2, { type: "disconnect" }))).subscribe()
+    );
+    const localLocations$ = state.observable.pipe(
+      map$1((s) => s.localLocations),
+      // Compared by value, not by reference. The Studio compares by reference and
+      // so never dedupes, because its form rebuilds the array on every call.
+      distinctUntilChanged(isEqualLocations)
+    ), rollCallRequests$ = incomingEvents$.pipe(
+      // Bifur echoes our own roll call back to us, since we are subscribed to the
+      // same topic we published to. Answering it would be a pointless round trip.
+      filter$1((event) => event.type === "rollCall" && event.sessionId !== sessionId)
+    );
+    subscription.add(
+      merge(
+        asTrigger(localLocations$, "locationChange"),
+        asTrigger(rollCallRequests$, "rollCall"),
+        asTrigger(connections$, "connection")
+      ).pipe(
+        switchMap(() => timer(0, REPORT_MIN_INTERVAL)),
+        withLatestFrom(localLocations$),
+        map$1(([, locations]) => locations),
+        // Stay silent until the app has reported at least once.
+        filter$1((locations) => locations !== void 0),
+        auditTime(REPORT_AUDIT_TIME),
+        switchMap((locations) => sendSafely(dispatch2, { type: "state", locations }))
+      ).subscribe()
+    );
+    const userIds$ = state.observable.pipe(
+      map$1(
+        (s) => Array.from(s.locations.values()).map((l) => l.userId).filter((id) => !!id)
+      ),
+      distinctUntilChanged((a, b) => a.length === b.length && a.every((v, i) => v === b[i]))
+    ), organizationId$ = isCanvasResource(resource) ? state.observable.pipe(
+      filter$1((s) => s.organizationId !== void 0 || s.organizationIdError !== void 0),
+      first$1(),
+      map$1((s) => s.organizationId)
+    ) : of(void 0);
+    if (subscription.add(
+      combineLatest([userIds$, organizationId$]).pipe(
+        switchMap(([userIds, organizationId]) => {
+          if (userIds.length === 0)
+            return of([]);
+          if (!isDatasetResource(resource) && !organizationId)
+            return of([]);
+          const userObservables = userIds.map(
+            (userId) => getUserState(instance, {
+              userId,
+              ...isDatasetResource(resource) ? { resourceType: "project", projectId: resource.projectId } : { resourceType: "organization", organizationId }
+            }).pipe(filter$1((v) => !!v))
+          );
+          return combineLatest(userObservables);
+        })
+      ).subscribe((users) => {
+        state.set("presence/users", (prevState) => ({
+          ...prevState,
+          users: {
+            ...prevState.users,
+            ...users.reduce((acc, user) => (user && (acc[user.profile.id] = user), acc), {})
+          }
         }));
       })
-    ), dispatch2({ type: "rollCall" }).subscribe(), isCanvasResource(resource)) {
+    ), isCanvasResource(resource)) {
       const globalClient = getClient(instance, { apiVersion: PRESENCE_API_VERSION });
       subscription.add(
         globalClient.observable.request({
           uri: `/canvases/${resource.canvasId}`,
           tag: "canvases.get"
-        }).pipe(catchError$1(() => EMPTY)).subscribe(({ organizationId }) => {
-          state.set("presence/organizationId", (prev) => ({ ...prev, organizationId }));
+        }).subscribe({
+          next: ({ organizationId }) => {
+            state.set("presence/organizationId", (prev) => ({ ...prev, organizationId }));
+          },
+          error: (organizationIdError) => {
+            state.set("presence/organizationIdError", (prev) => ({ ...prev, organizationIdError }));
+          }
         })
       );
     }
     return () => {
-      dispatch2({ type: "disconnect" }).subscribe(), subscription.unsubscribe();
+      sendSafely(dispatch2, { type: "disconnect" }).subscribe(), subscription.unsubscribe();
     };
   }
-}), selectLocations = (state) => state.locations, selectUsers = (state) => state.users, selectPresence = createSelector(
+}), selectLocations = (state) => state.locations, selectUsers = (state) => state.users, createUnresolvedUser = (userId) => ({
+  sanityUserId: userId,
+  profile: {
+    id: userId,
+    displayName: "Unknown user",
+    email: "",
+    provider: "",
+    createdAt: ""
+  },
+  memberships: []
+}), selectPresence = createSelector(
   selectLocations,
   selectUsers,
   (locations, users) => Array.from(locations.entries()).map(([sessionId, { userId, locations: locs }]) => ({
-    user: users[userId] || {
-      id: userId,
-      displayName: "Unknown user",
-      name: "Unknown user",
-      email: ""
-    },
+    user: users[userId] || createUnresolvedUser(userId),
     sessionId,
     locations: locs
   }))
-), _getPresence = bindActionByResource(
+), documentPresenceCache = /* @__PURE__ */ new WeakMap();
+function selectDocumentPresence(state, options) {
+  const cacheKey = JSON.stringify([
+    getEditingDocumentId(options),
+    options.path ?? null,
+    options.excludeVersions ?? !1
+  ]);
+  let perState = documentPresenceCache.get(state);
+  perState || (perState = /* @__PURE__ */ new Map(), documentPresenceCache.set(state, perState));
+  const cached = perState.get(cacheKey);
+  if (cached) return cached;
+  const computed = computeDocumentPresence(state, options);
+  return perState.set(cacheKey, computed), computed;
+}
+const scopeId = (documentId, excludeVersions) => excludeVersions ? documentId : getPublishedId(DocumentId(documentId)), pathOf = (location) => location.path;
+function matchesQuery(location, target, { path, excludeVersions }) {
+  return scopeId(location.documentId, excludeVersions) !== target ? !1 : !path || startsWithPath(path, pathOf(location));
+}
+function toDocumentPresence(users, sessionId, userId, location) {
+  return {
+    user: users[userId] || createUnresolvedUser(userId),
+    sessionId,
+    documentId: location.documentId,
+    path: pathOf(location),
+    lastActiveAt: location.lastActiveAt,
+    ...location.selection === void 0 ? {} : { selection: location.selection }
+  };
+}
+function computeDocumentPresence(state, options) {
+  const target = scopeId(getEditingDocumentId(options), options.excludeVersions);
+  return Array.from(state.locations).flatMap(
+    ([sessionId, session]) => session.locations.filter((location) => matchesQuery(location, target, options)).map((location) => toDocumentPresence(state.users, sessionId, session.userId, location))
+  );
+}
+const _getPresence = bindActionByResource(
   presenceStore,
   createStateSourceAction({
-    selector: (context) => selectPresence(context.state),
-    onSubscribe: (context) => {
-      const resource = context.key.resource, userIds$ = context.state.observable.pipe(
-        map$1(
-          (state) => Array.from(state.locations.values()).map((l) => l.userId).filter((id) => !!id)
-        ),
-        distinctUntilChanged((a, b) => a.length === b.length && a.every((v, i) => v === b[i]))
-      ), organizationId$ = isCanvasResource(resource) ? context.state.observable.pipe(
-        map$1((s) => s.organizationId),
-        filter$1((id) => id !== void 0),
-        first$1()
-      ) : of(void 0), subscription = combineLatest([userIds$, organizationId$]).pipe(
-        switchMap(([userIds, organizationId]) => {
-          if (userIds.length === 0)
-            return of([]);
-          const userObservables = userIds.map(
-            (userId) => getUserState(context.instance, {
-              userId,
-              ...isDatasetResource(resource) ? { resourceType: "project", projectId: resource.projectId } : { resourceType: "organization", organizationId }
-            }).pipe(filter$1((v) => !!v))
-          );
-          return combineLatest(userObservables);
-        })
-      ).subscribe((users) => {
-        context.state.set("presence/users", (prevState) => ({
-          ...prevState,
-          users: {
-            ...prevState.users,
-            ...users.reduce((acc, user) => (user && (acc[user.profile.id] = user), acc), {})
-          }
-        }));
-      });
-      return () => subscription.unsubscribe();
-    }
+    selector: (context) => selectPresence(context.state)
   })
 );
 function getPresence(instance, params) {
   return _getPresence(instance, params ?? {});
 }
+const _getDocumentPresence = bindActionByResource(
+  presenceStore,
+  createStateSourceAction({
+    selector: ({ state }, options) => selectDocumentPresence(state, options)
+  })
+);
+function getDocumentPresence(instance, params) {
+  return _getDocumentPresence(instance, params);
+}
+const _reportPresence = bindActionByResource(
+  presenceStore,
+  ({ state }, { locations }) => {
+    const lastActiveAt = (/* @__PURE__ */ new Date()).toISOString(), wireLocations = locations.map((location) => ({
+      type: "document",
+      // The specific document being edited, not the canonical id. Other clients,
+      // the Studio included, compare exact ids for field-level presence.
+      documentId: getEditingDocumentId(location),
+      path: location.path ?? [],
+      lastActiveAt,
+      ...location.selection === void 0 ? {} : { selection: location.selection }
+    }));
+    state.set("presence/report", (prevState) => ({ ...prevState, localLocations: wireLocations }));
+  }
+);
+function reportPresence(instance, params) {
+  return _reportPresence(instance, params);
+}
 function hashString(str) {
   let hash = 0;
   for (let i = 0; i < str.length; i++)
@@ -3875,6 +4057,7 @@ export {
   getCurrentUserState,
   getDashboardOrganizationId$1 as getDashboardOrganizationId,
   getDatasetsState,
+  getDocumentPresence,
   getDocumentState,
   getDocumentSyncStatus,
   getFavoritesState,
@@ -3923,6 +4106,7 @@ export {
   publishRelease,
   releaseChannel,
   releaseNode,
+  reportPresence,
   resolveDatasets,
   resolveDocument,
   resolveFavoritesState,