@sanity/sdk 2.17.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, 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, Observable, NEVER, fromEvent, Subscription, debounceTime, defer } 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));
 }
@@ -726,20 +731,40 @@ const ensureArrayKeysDeep = memoize((input) => {
   const entries = Object.entries(input).map(([key, value]) => [key, ensureArrayKeysDeep(value)]);
   return entries.every(([key, value]) => input[key] === value) ? input : Object.fromEntries(entries);
 });
+function resolvesArraySegments(input, path) {
+  let current = input;
+  for (const segment of path) {
+    if (typeof segment == "string") {
+      current = typeof current == "object" && current !== null && !Array.isArray(current) ? current[segment] : void 0;
+      continue;
+    }
+    if (!Array.isArray(current)) return !1;
+    if (isKeySegment(segment)) {
+      const index = getIndexForKey(current, segment._key);
+      if (index === void 0) return !1;
+      current = current[index];
+    } else {
+      const index = segment < 0 ? current.length + segment : segment;
+      if (!(index in current)) return !1;
+      current = current[index];
+    }
+  }
+  return !0;
+}
 function set(input, pathExpressionValues) {
   const result = Object.entries(pathExpressionValues).flatMap(
     ([pathExpression, replacementValue]) => Array.from(jsonMatch(input, pathExpression)).map((matchEntry) => ({
       ...matchEntry,
       replacementValue
     }))
-  ).reduce((acc, { path, replacementValue }) => setDeep(acc, path, replacementValue), input);
+  ).filter(({ path }) => resolvesArraySegments(input, path)).reduce((acc, { path, replacementValue }) => setDeep(acc, path, replacementValue), input);
   return ensureArrayKeysDeep(result);
 }
 function setIfMissing(input, pathExpressionValues) {
   const result = Object.entries(pathExpressionValues).flatMap(([pathExpression, replacementValue]) => Array.from(jsonMatch(input, pathExpression)).map((matchEntry) => ({
     ...matchEntry,
     replacementValue
-  }))).filter((matchEntry) => matchEntry.value === null || matchEntry.value === void 0).reduce((acc, { path, replacementValue }) => setDeep(acc, path, replacementValue), input);
+  }))).filter((matchEntry) => matchEntry.value === null || matchEntry.value === void 0).filter(({ path }) => resolvesArraySegments(input, path)).reduce((acc, { path, replacementValue }) => setDeep(acc, path, replacementValue), input);
   return ensureArrayKeysDeep(result);
 }
 function unset(input, pathExpressions) {
@@ -1040,6 +1065,24 @@ class MaxBufferExceededError extends OutOfSyncError {
     super(message, state), this.name = "MaxBufferExceededError";
   }
 }
+function toOrderedChains(events) {
+  return events.filter(
+    (event) => !events.some((other) => other.resultRev === event.previousRev)
+  ).map((start) => {
+    const chain = [];
+    let current = start;
+    for (; current; ) {
+      chain.push(current);
+      const currentResultRev = current.resultRev;
+      current = events.find((event) => event.previousRev === currentResultRev);
+    }
+    return chain;
+  });
+}
+function discardChainTo(chain, revision) {
+  const revisionIndex = chain.findIndex((event) => event.resultRev === revision);
+  return revisionIndex === -1 ? chain : chain.slice(revisionIndex + 1);
+}
 function sortListenerEvents(options) {
   const { resolveChainDeadline = DEFAULT_DEADLINE_MS, maxBufferSize = DEFAULT_MAX_BUFFER_SIZE } = {};
   return (input$) => input$.pipe(
@@ -1058,25 +1101,25 @@ function sortListenerEvents(options) {
             throw new Error(
               "Invalid state. Cannot process mutation event without a base sync event"
             );
-          const buffer = state.buffer.concat(event), emitEvents = [];
-          let baseRevision = state.base.revision, progress = !0;
-          for (; progress; ) {
-            progress = !1;
-            const idx = buffer.findIndex((e) => e.previousRev === baseRevision);
-            if (idx !== -1) {
-              const [next] = buffer.splice(idx, 1);
-              emitEvents.push(next), baseRevision = next.transition === "disappear" ? void 0 : next.resultRev, progress = !0;
-            }
+          const baseRevision = state.base.revision, chains = toOrderedChains(state.buffer.concat(event)).map((chain) => discardChainTo(chain, baseRevision)).filter((chain) => chain.length > 0), applicable = chains.find((chain) => chain[0].previousRev === baseRevision), buffer = chains.filter((chain) => chain !== applicable).flat();
+          if (applicable) {
+            const last = applicable[applicable.length - 1];
+            return {
+              // If the chain ends in a deletion, the new base revision is undefined.
+              base: { revision: last.transition === "disappear" ? void 0 : last.resultRev },
+              buffer,
+              emitEvents: applicable
+            };
           }
           if (buffer.length >= maxBufferSize)
             throw new MaxBufferExceededError(
               `Too many unchainable mutation events (${buffer.length}) waiting to resolve.`,
-              { base: { revision: baseRevision }, buffer, emitEvents }
+              { base: { revision: baseRevision }, buffer, emitEvents: [] }
             );
           return {
             base: { revision: baseRevision },
             buffer,
-            emitEvents
+            emitEvents: []
           };
         }
         return { ...state, emitEvents: [event] };
@@ -1107,7 +1150,7 @@ function sortListenerEvents(options) {
 const listen = ({ state }, documentId) => {
   const { sharedListener, fetchDocument } = state.get();
   return sharedListener.events.pipe(
-    concatMap((e) => e.type === "welcome" ? fetchDocument(documentId).pipe(
+    concatMap((e) => e.type === "welcome" || e.type === "reset" ? fetchDocument(documentId).pipe(
       map$1((document) => ({ type: "sync", document }))
     ) : e.type === "mutation" && e.documentId === documentId ? of(e) : EMPTY),
     sortListenerEvents(),
@@ -1236,6 +1279,53 @@ function createMutationApplier(options) {
     }
   };
 }
+function preserveNumericOperations(baseBefore, userPatches, diffedPatches) {
+  if (!baseBefore || !userPatches?.length) return diffedPatches;
+  const targets = /* @__PURE__ */ new Map();
+  for (const patch of userPatches)
+    for (const [op, sign] of [
+      ["inc", 1],
+      ["dec", -1]
+    ]) {
+      const record = patch[op];
+      if (record) {
+        for (const [pathExpression, amount] of Object.entries(record))
+          if (typeof amount == "number")
+            for (const match of jsonMatch(baseBefore, pathExpression)) {
+              const path = stringifyPath(match.path), existing = targets.get(path);
+              existing ? (existing.expectedValue += sign * amount, existing.delta += sign * amount) : typeof match.value == "number" && targets.set(path, {
+                baseValue: match.value,
+                expectedValue: match.value + sign * amount,
+                delta: sign * amount
+              });
+            }
+      }
+    }
+  if (!targets.size) return diffedPatches;
+  const preserved = /* @__PURE__ */ new Map(), next = diffedPatches.flatMap((patch) => {
+    if (!patch.set) return [patch];
+    const keptSet = {};
+    for (const [path, value] of Object.entries(patch.set)) {
+      const target = targets.get(path);
+      target && typeof value == "number" && value === target.expectedValue ? preserved.set(path, { delta: target.delta, baseValue: target.baseValue }) : keptSet[path] = value;
+    }
+    if (Object.keys(keptSet).length === Object.keys(patch.set).length) return [patch];
+    const { set: _set, ...rest } = patch, withKept = Object.keys(keptSet).length ? { ...rest, set: keptSet } : rest;
+    return Object.keys(withKept).length ? [withKept] : [];
+  });
+  if (!preserved.size) return next;
+  const setIfMissing2 = {}, inc2 = {}, dec2 = {};
+  for (const [path, { delta, baseValue }] of preserved)
+    setIfMissing2[path] = baseValue, delta >= 0 ? inc2[path] = delta : dec2[path] = -delta;
+  return [
+    ...next,
+    {
+      setIfMissing: setIfMissing2,
+      ...Object.keys(inc2).length && { inc: inc2 },
+      ...Object.keys(dec2).length && { dec: dec2 }
+    }
+  ];
+}
 function applySingleDocPatch({
   base: initialBase,
   working: initialWorking,
@@ -1262,7 +1352,11 @@ function applySingleDocPatch({
     preserveOperations
   }), baseBefore = base[documentId];
   base = applyMutations(base, userPatches, "base");
-  const baseAfter = base[documentId], diffedPatches = preserveOperations ? patches : diffValue(baseBefore, baseAfter), workingBefore = working[documentId];
+  const baseAfter = base[documentId], diffedPatches = preserveOperations ? patches : preserveNumericOperations(
+    baseBefore,
+    patches,
+    diffValue(baseBefore, baseAfter)
+  ), workingBefore = working[documentId];
   if (!checkGrant(grants.update, workingBefore, identity))
     throw new PermissionActionError({ documentId, transactionId, message: permissionMessage });
   const workingMutations = diffedPatches.map((patch) => ({
@@ -1599,7 +1693,11 @@ function handleEdit(action, ctx) {
   !isReleasePerspective(action.perspective) && !base[draftId] && base[publishedId] && baseMutations.push({ create: { ...base[publishedId], _id: draftId } });
   const baseBefore = base[patchDocumentId] ?? base[publishedId];
   userPatches && baseMutations.push(...userPatches), base = applyMutations(base, baseMutations, "base");
-  const baseAfter = base[patchDocumentId], patches = action.preserveOperations ? action.patches ?? [] : diffValue(baseBefore, baseAfter), workingMutations = [];
+  const baseAfter = base[patchDocumentId], patches = action.preserveOperations ? action.patches ?? [] : preserveNumericOperations(
+    baseBefore,
+    action.patches,
+    diffValue(baseBefore, baseAfter)
+  ), workingMutations = [];
   if (!isReleasePerspective(action.perspective) && !working[draftId] && working[publishedId]) {
     const newDraftFromPublished = { ...working[publishedId], _id: draftId };
     if (!checkGrant(grants.create, newDraftFromPublished, identity))
@@ -2212,7 +2310,8 @@ function applyRemoteDocument(prev, { document, documentId, previousRev, revision
   }
   if (type === "sync" && (unverifiedRevisions = Object.fromEntries(
     Object.entries(unverifiedRevisions).filter(([, unverifiedRevision]) => unverifiedRevision ? new Date(timestamp).getTime() <= new Date(unverifiedRevision.timestamp).getTime() : !1)
-  )), revisionToVerify && revisionToVerify.previousRev === previousRev)
+  )), revisionToVerify && revisionToVerify.previousRev === previousRev) {
+    const modifiesDocument = (transaction) => transaction.working[documentId]?._rev !== transaction.previousRevs[documentId], local2 = !prev.applied.some(modifiesDocument) && (!prev.outgoing || prev.outgoing.transactionId === revision || !modifiesDocument(prev.outgoing)) && !isDeepEqual(prevDocState.local, document) ? document : prevDocState.local;
     return {
       ...prev,
       documentStates: {
@@ -2221,10 +2320,12 @@ function applyRemoteDocument(prev, { document, documentId, previousRev, revision
           ...prevDocState,
           remote: document,
           remoteRev: revision,
+          local: local2,
           unverifiedRevisions
         }
       }
     };
+  }
   let working = { ...prev.applied.at(0)?.previous, [documentId]: document };
   const nextApplied = [];
   for (const curr of prev.applied)
@@ -2244,6 +2345,7 @@ function applyRemoteDocument(prev, { document, documentId, previousRev, revision
       }
       throw error;
     }
+  const nextLocal = working[documentId], local = isDeepEqual(prevDocState.local, nextLocal) ? prevDocState.local : nextLocal;
   return {
     ...prev,
     applied: nextApplied,
@@ -2253,7 +2355,7 @@ function applyRemoteDocument(prev, { document, documentId, previousRev, revision
         ...prevDocState,
         remote: document,
         remoteRev: revision,
-        local: working[documentId],
+        local,
         unverifiedRevisions
       }
     }
@@ -2345,6 +2447,85 @@ function getDocumentEvents(outgoing) {
     )
   );
 }
+const DEDUPE_TTL = 12e4, DEDUPE_MAX_ENTRIES = 1e3, GROUP_FLUSH_DEADLINE = 3e4, GROUP_MAX_HELD_EVENTS = 100;
+function dedupeListenerEvents(options) {
+  const { ttl = DEDUPE_TTL, maxEntries = DEDUPE_MAX_ENTRIES } = {};
+  return (source) => defer(() => {
+    const seen = /* @__PURE__ */ new Map();
+    return source.pipe(
+      filter$1((event) => {
+        if (event.type !== "mutation") return !0;
+        const key = `${event.transactionId}#${event.documentId}`, now = Date.now(), expiry = seen.get(key);
+        if (expiry !== void 0 && expiry > now) return !1;
+        seen.delete(key), seen.set(key, now + ttl);
+        for (const [existingKey, existingExpiry] of seen) {
+          if (seen.size <= maxEntries && existingExpiry > now) break;
+          seen.delete(existingKey);
+        }
+        return !0;
+      })
+    );
+  });
+}
+function groupTransactionEvents(options) {
+  const { flushDeadline = GROUP_FLUSH_DEADLINE, maxHeldEvents = GROUP_MAX_HELD_EVENTS } = {};
+  return (source) => new Observable((subscriber) => {
+    let open = null, held = [];
+    const closeOpen = () => {
+      if (!open) return;
+      clearTimeout(open.timer);
+      const { events } = open;
+      open = null;
+      for (const event of events) subscriber.next(event);
+    }, releaseHeld = () => {
+      const queue = held;
+      held = [];
+      for (const event of queue) processEvent(event);
+    }, releaseEverything = () => {
+      closeOpen();
+      const queue = held;
+      held = [];
+      for (const event of queue) subscriber.next(event);
+    }, processEvent = (event) => {
+      if (event.type !== "mutation") {
+        releaseEverything(), subscriber.next(event);
+        return;
+      }
+      const isMultiDocument = (event.transactionTotalEvents ?? 0) > 1;
+      if (!open) {
+        if (!isMultiDocument) {
+          subscriber.next(event);
+          return;
+        }
+        open = {
+          transactionId: event.transactionId,
+          events: [event],
+          total: event.transactionTotalEvents,
+          timer: setCleanupTimeout(() => {
+            closeOpen(), releaseHeld();
+          }, flushDeadline)
+        };
+        return;
+      }
+      if (event.transactionId === open.transactionId) {
+        open.events.push(event), open.events.length >= open.total && (closeOpen(), releaseHeld());
+        return;
+      }
+      held.push(event), held.length > maxHeldEvents && releaseEverything();
+    }, subscription = source.subscribe({
+      next: processEvent,
+      error: (error) => {
+        releaseEverything(), subscriber.error(error);
+      },
+      complete: () => {
+        releaseEverything(), subscriber.complete();
+      }
+    });
+    return () => {
+      open && clearTimeout(open.timer), open = null, held = [], subscription.unsubscribe();
+    };
+  });
+}
 const API_VERSION$3 = "v2025-05-06";
 function createSharedListener(instance, resource) {
   const dispose$ = new Subject(), events$ = getClientState(instance, {
@@ -2360,7 +2541,12 @@ function createSharedListener(instance, resource) {
           "*",
           {},
           {
-            events: ["mutation", "welcome", "reconnect"],
+            // with `enableResume`, a reconnect replays the events missed while
+            // offline (emitting `welcomeback`) instead of forcing a refetch of
+            // every subscribed document. when the backend cannot resume, it
+            // emits `welcome` or `reset`, both of which trigger a refetch
+            events: ["mutation", "welcome", "welcomeback", "reconnect", "reset"],
+            enableResume: !0,
             includeResult: !1,
             // the document store handles version documents, so we need to include all versions
             includeAllVersions: !0,
@@ -2373,6 +2559,11 @@ function createSharedListener(instance, resource) {
         )
       )
     ),
+    // resumed events are delivered at-least-once, so drop replayed duplicates
+    dedupeListenerEvents(),
+    // hold multi-document transactions (e.g. publish) until complete so
+    // per-document processing never observes half a transaction
+    groupTransactionEvents(),
     takeUntil(dispose$),
     share()
   ), [welcome$, mutation$] = partition(events$, (e) => e.type === "welcome");
@@ -2652,8 +2843,7 @@ const _resolveDocument = bindActionByResource(
     switchMap(
       (client) => client.observable.request({
         uri,
-        tag: "acl.get",
-        withCredentials: !0
+        tag: "acl.get"
       })
     ),
     tap$1((datasetAcl) => state.set("setGrants", { grants: createGrantsLookup(datasetAcl) }))
@@ -3057,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,
@@ -3103,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 });
@@ -3117,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) => {
@@ -3141,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++)
@@ -3690,6 +4057,7 @@ export {
   getCurrentUserState,
   getDashboardOrganizationId$1 as getDashboardOrganizationId,
   getDatasetsState,
+  getDocumentPresence,
   getDocumentState,
   getDocumentSyncStatus,
   getFavoritesState,
@@ -3738,6 +4106,7 @@ export {
   publishRelease,
   releaseChannel,
   releaseNode,
+  reportPresence,
   resolveDatasets,
   resolveDocument,
   resolveFavoritesState,