@sanity/sdk 2.16.0 → 2.18.0

package/dist/index.js

@@ -1,4 +1,4 @@
-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 { 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 { 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";
@@ -620,22 +620,24 @@ function convertSanityMutatePatch(sanityPatchMutation) {
     return "id" in copy && delete copy.id, copy;
   });
 }
-function editDocument(doc, patches) {
-  const effectiveDocumentId = getEffectiveDocumentId(doc);
+function editDocument(doc, patches, options) {
+  const effectiveDocumentId = getEffectiveDocumentId(doc), preserveOperations = options?.preserveOperations && { preserveOperations: !0 };
   if (isSanityMutatePatch(patches)) {
     const converted = convertSanityMutatePatch(patches) ?? [];
     return {
       ...doc,
       type: "document.edit",
       documentId: effectiveDocumentId,
-      patches: converted
+      patches: converted,
+      ...preserveOperations
     };
   }
   return {
     ...doc,
     type: "document.edit",
     documentId: effectiveDocumentId,
-    ...patches && { patches: Array.isArray(patches) ? patches : [patches] }
+    ...patches && { patches: Array.isArray(patches) ? patches : [patches] },
+    ...preserveOperations
   };
 }
 function publishDocument(doc) {
@@ -724,20 +726,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) {
@@ -1038,6 +1060,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(
@@ -1056,25 +1096,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] };
@@ -1105,7 +1145,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(),
@@ -1139,6 +1179,7 @@ const listen = ({ state }, documentId) => {
         document: document ?? null,
         revision: transactionId,
         timestamp,
+        mutations: next.mutations,
         ...previousRev && { previousRev }
       };
     })
@@ -1219,6 +1260,67 @@ class ActionError extends Error {
 }
 class PermissionActionError extends ActionError {
 }
+function createMutationApplier(options) {
+  const { documentId, transactionId, timestamp, preserveOperations } = options;
+  return (documents, mutations, documentSetName) => {
+    try {
+      return processMutations({ documents, transactionId, mutations, timestamp });
+    } catch (error) {
+      throw preserveOperations ? new ActionError({
+        documentId,
+        transactionId,
+        message: `Failed to apply patches to the ${documentSetName} document: ${error instanceof Error ? error.message : "Unknown error"}`
+      }) : error;
+    }
+  };
+}
+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,
@@ -1229,7 +1331,8 @@ function applySingleDocPatch({
   grants,
   identity,
   notFoundMessage = "Cannot edit document because it does not exist.",
-  permissionMessage = `You do not have permission to edit document "${documentId}".`
+  permissionMessage = `You do not have permission to edit document "${documentId}".`,
+  preserveOperations
 }) {
   let base = initialBase, working = initialWorking;
   const userPatches = patches?.map((patch) => ({ patch: { id: documentId, ...patch } }));
@@ -1237,20 +1340,24 @@ function applySingleDocPatch({
     return { base, working, diffedPatches: [], workingMutations: [] };
   if (!working[documentId] || !base[documentId])
     throw new ActionError({ documentId, transactionId, message: notFoundMessage });
-  const baseBefore = base[documentId];
-  base = processMutations({ documents: base, transactionId, mutations: userPatches, timestamp });
-  const baseAfter = base[documentId], diffedPatches = diffValue(baseBefore, baseAfter), workingBefore = working[documentId];
+  const applyMutations = createMutationApplier({
+    documentId,
+    transactionId,
+    timestamp,
+    preserveOperations
+  }), baseBefore = base[documentId];
+  base = applyMutations(base, userPatches, "base");
+  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) => ({
     patch: { id: documentId, ...patch }
   }));
-  return working = processMutations({
-    documents: working,
-    transactionId,
-    mutations: workingMutations,
-    timestamp
-  }), { base, working, diffedPatches, workingMutations };
+  return working = applyMutations(working, workingMutations, "working"), { base, working, diffedPatches, workingMutations };
 }
 function createGrantsLookup(datasetAcl) {
   const filtersByGrant = {
@@ -1550,7 +1657,8 @@ function handleEdit(action, ctx) {
       transactionId,
       timestamp,
       grants,
-      identity
+      identity,
+      preserveOperations: action.preserveOperations
     });
     return outgoingMutations.push(...result.workingMutations), { base: result.base, working: result.working };
   }
@@ -1571,16 +1679,20 @@ function handleEdit(action, ctx) {
       transactionId,
       message: "Cannot edit document because it does not exist in draft or published form."
     });
-  const baseMutations = [];
+  const applyMutations = createMutationApplier({
+    documentId,
+    transactionId,
+    timestamp,
+    preserveOperations: action.preserveOperations
+  }), baseMutations = [];
   !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 = processMutations({
-    documents: base,
-    transactionId,
-    mutations: baseMutations,
-    timestamp
-  });
-  const baseAfter = base[patchDocumentId], patches = diffValue(baseBefore, baseAfter), workingMutations = [];
+  userPatches && baseMutations.push(...userPatches), base = applyMutations(base, baseMutations, "base");
+  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))
@@ -1598,12 +1710,7 @@ function handleEdit(action, ctx) {
       transactionId,
       message: `You do not have permission to edit document "${documentId}".`
     });
-  return workingMutations.push(...patches.map((patch) => ({ patch: { id: patchDocumentId, ...patch } }))), working = processMutations({
-    documents: working,
-    transactionId,
-    mutations: workingMutations,
-    timestamp
-  }), outgoingMutations.push(...workingMutations), outgoingActions.push(
+  return workingMutations.push(...patches.map((patch) => ({ patch: { id: patchDocumentId, ...patch } }))), working = applyMutations(working, workingMutations, "working"), outgoingMutations.push(...workingMutations), outgoingActions.push(
     ...patches.map((patch) => ({
       actionType: "sanity.action.document.edit",
       draftId: patchDocumentId,
@@ -2109,7 +2216,16 @@ function transitionAppliedTransactionsToOutgoing(prev) {
             ...documentState.unverifiedRevisions,
             // add unverified revision
             [transactionId]: { documentId, previousRev, transactionId, timestamp }
-          }
+          },
+          // also track the transaction ID durably (unverified revisions can be
+          // pruned by sync events before the listener echo arrives) so
+          // `remote-patches` events label our own transactions correctly
+          recentOwnTransactionIds: [
+            ...(documentState.recentOwnTransactionIds ?? []).slice(
+              -49
+            ),
+            transactionId
+          ]
         }), acc;
       },
       { ...prev.documentStates }
@@ -2159,15 +2275,38 @@ function revertOutgoingTransaction(prev) {
     )
   };
 }
-function applyRemoteDocument(prev, { document, documentId, previousRev, revision, timestamp, type }, events) {
+function extractPatchOperations(mutations, documentId) {
+  return mutations ? mutations.flatMap((mutation) => {
+    if (!("patch" in mutation) || !mutation.patch) return [];
+    const { id, ...operations } = mutation.patch;
+    return id !== documentId ? [] : [operations];
+  }) : [];
+}
+function applyRemoteDocument(prev, { document, documentId, previousRev, revision, timestamp, type, mutations }, events) {
   if (!prev.grants) return prev;
   const prevDocState = prev.documentStates[documentId];
   if (!prevDocState) return prev;
   const prevUnverifiedRevisions = prevDocState.unverifiedRevisions, revisionToVerify = revision ? prevUnverifiedRevisions?.[revision] : void 0;
   let unverifiedRevisions = prevUnverifiedRevisions ?? EMPTY_REVISIONS;
-  if (revision && revisionToVerify && (unverifiedRevisions = omitProperty(prevUnverifiedRevisions, revision)), type === "sync" && (unverifiedRevisions = Object.fromEntries(
+  if (revision && revisionToVerify && (unverifiedRevisions = omitProperty(prevUnverifiedRevisions, revision)), type === "mutation" && revision) {
+    const patches = extractPatchOperations(mutations, documentId);
+    if (patches.length) {
+      const isOwnTransaction = !!revisionToVerify || (prevDocState.recentOwnTransactionIds?.includes(revision) ?? !1);
+      events.next({
+        type: "remote-patches",
+        documentId,
+        transactionId: revision,
+        previousRev,
+        timestamp,
+        patches,
+        origin: isOwnTransaction ? "local" : "remote"
+      });
+    }
+  }
+  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: {
@@ -2176,10 +2315,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)
@@ -2199,6 +2340,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,
@@ -2208,7 +2350,7 @@ function applyRemoteDocument(prev, { document, documentId, previousRev, revision
         ...prevDocState,
         remote: document,
         remoteRev: revision,
-        local: working[documentId],
+        local,
         unverifiedRevisions
       }
     }
@@ -2300,6 +2442,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, {
@@ -2315,7 +2536,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,
@@ -2328,6 +2554,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");
@@ -2607,8 +2838,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) }))