@sanity/sdk 3.12.0 → 3.13.0-next.20261106104949

package/dist/index.js

@@ -5,18 +5,17 @@ import { a as compareProjectOrganization, i as projects, n as threadComments, o
 import { r as omitProperty, t as isDeepEqual } from "./object-CxXlSVg7.js";
 import { n as getClient, r as getClientState } from "./clientStore-C20oRB2w.js";
 import { n as getDashboardOrganizationId } from "./topicStore-BKyvThWM.js";
-import { _ as updateLastLoadMoreRequest, a as resolveQuery, b as favorites, c as getAllReleasesState, d as getUsersKey, f as initializeRequest, g as setUsersError, h as setUsersData, l as addSubscription, m as removeSubscription, o as getPerspectiveState, p as parseUsersKey, r as getQueryState, s as getActiveReleasesState, t as CORE_SDK_VERSION, u as cancelRequest, v as PROJECT_API_VERSION, w as getProjectAccessErrorProjectId, x as setFavorite, y as USERS_STATE_CLEAR_DELAY } from "./version-DfqE7Tzw.js";
+import { A as patchOperations, C as ActionError, D as createMutationApplier, E as checkGrant, N as getProjectAccessErrorProjectId, O as preserveNumericOperations, T as applySingleDocPatch, _ as updateLastLoadMoreRequest, a as resolveQuery, b as favorites, c as getAllReleasesState, d as getUsersKey, f as initializeRequest, g as setUsersError, h as setUsersData, j as processMutations, k as getId, l as addSubscription, m as removeSubscription, o as getPerspectiveState, p as parseUsersKey, r as getQueryState, s as getActiveReleasesState, t as CORE_SDK_VERSION, u as cancelRequest, v as PROJECT_API_VERSION, w as PermissionActionError, x as setFavorite, y as USERS_STATE_CLEAR_DELAY } from "./version-DRnj2zr5.js";
 import { ClientError, CorsOriginError } from "@sanity/client";
 import { EMPTY, NEVER, Observable, ReplaySubject, Subject, Subscription, auditTime, catchError, combineLatest, concat, concatMap, debounceTime, defer, distinctUntilChanged, filter, first, firstValueFrom, from, fromEvent, groupBy, map, merge, mergeMap, of, pairwise, partition, race, share, skip, startWith, switchMap, take, takeUntil, tap, throttle, throwError, timer, withLatestFrom } from "rxjs";
-import { isKeySegment, isKeyedObject } from "@sanity/types";
+import "@sanity/types";
 import { createSelector } from "reselect";
 import { DocumentId, getDraftId, getPublishedId, getVersionId, isDraftId, isPublishedId, isVersionId } from "@sanity/id-utils";
-import { getIndexForKey, getIndexForKey as getIndexForKey$1, getPathDepth, joinPaths, jsonMatch, jsonMatch as jsonMatch$1, slicePath, slicePath as slicePath$1, stringifyPath, stringifyPath as stringifyPath$1 } from "@sanity/json-match";
+import { getIndexForKey, getPathDepth, joinPaths, jsonMatch, jsonMatch as jsonMatch$1, slicePath, stringifyPath } from "@sanity/json-match";
 import { SanityEncoder } from "@sanity/mutate";
 import { createDocumentLoaderFromClient } from "@sanity/mutate/_unstable_store";
-import { evaluateSync, parse } from "groq-js";
+import { parse } from "groq-js";
 import { catchError as catchError$1, distinctUntilChanged as distinctUntilChanged$1, map as map$1, mergeMap as mergeMap$1, retry as retry$1, scan, share as share$1, switchMap as switchMap$1 } from "rxjs/operators";
-import { applyPatches, parsePatch } from "@sanity/diff-match-patch";
 import { diffValue } from "@sanity/diff-patch";
 import { fromUrl } from "@sanity/bifur-client";
 /**
@@ -1751,352 +1750,6 @@ const RELEASE_ACTION_TYPES = /* @__PURE__ */ new Set([
 function isReleaseAction(action) {
 	return RELEASE_ACTION_TYPES.has(action.type);
 }
-function generateArrayKey(length = 12) {
-	let numBytes = Math.ceil(length / 2), bytes = crypto.getRandomValues(new Uint8Array(numBytes));
-	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, length);
-}
-function memoize(fn) {
-	let cache = /* @__PURE__ */ new WeakMap();
-	return ((input) => {
-		if (!input || typeof input != "object") return fn(input);
-		let cached = cache.get(input);
-		if (cached) return cached;
-		let result = fn(input);
-		return cache.set(input, result), result;
-	});
-}
-/**
-* Recursively traverse a value. When an array is encountered, ensure that
-* each object item has a _key property. Memoized such that sub-objects that
-* have not changed aren't re-computed.
-*/
-const ensureArrayKeysDeep = memoize((input) => {
-	if (!input || typeof input != "object") return input;
-	if (Array.isArray(input)) return !input.length || typeof input[0] != "object" || input.every(isKeyedObject) ? input : input.map((item) => !item || typeof item != "object" ? item : isKeyedObject(item) ? ensureArrayKeysDeep(item) : {
-		...ensureArrayKeysDeep(item),
-		_key: generateArrayKey()
-	});
-	let entries = Object.entries(input).map(([key, value]) => [key, ensureArrayKeysDeep(value)]);
-	return entries.every(([key, value]) => input[key] === value) ? input : Object.fromEntries(entries);
-});
-/**
-* Whether every array-addressing segment (keyed `[_key=="…"]` or numeric
-* index) in the given match path resolves to an existing array item.
-*
-* This mirrors Content Lake, which auto-creates missing *object* properties
-* when setting but never creates *array items*:
-*
-* ```js
-* // object properties are created, even nested ones:
-* set({}, {'meta.author.name': 'Ada'})
-* // -> {meta: {author: {name: 'Ada'}}}                    (applies)
-*
-* // array items are not:
-* set({items: [{_key: 'a'}]}, {'items[_key=="b"].title': 'x'})
-* // -> {items: [{_key: 'a'}]}                             (no-op)
-* ```
-*
-* Without this filter, the second example fabricated a degenerate item
-* (`{title: 'x'}`, no `_key`) that would never exist on the server, which
-* is how concurrent Portable Text edits grew phantom span-less children.
-*/
-function resolvesArraySegments(input, path) {
-	let current = input;
-	for (let segment of path) if (typeof segment == "string") current = typeof current == "object" && current && !Array.isArray(current) ? current[segment] : void 0;
-	else {
-		if (!Array.isArray(current)) return !1;
-		if (isKeySegment(segment)) {
-			let index = getIndexForKey$1(current, segment._key);
-			if (index === void 0) return !1;
-			current = current[index];
-		} else {
-			let index = segment < 0 ? current.length + segment : segment;
-			if (!(index in current)) return !1;
-			current = current[index];
-		}
-	}
-	return !0;
-}
-function set(input, pathExpressionValues) {
-	let result = Object.entries(pathExpressionValues).flatMap(([pathExpression, replacementValue]) => Array.from(jsonMatch$1(input, pathExpression)).map((matchEntry) => ({
-		...matchEntry,
-		replacementValue
-	}))).filter(({ path }) => resolvesArraySegments(input, path)).reduce((acc, { path, replacementValue }) => setDeep(acc, path, replacementValue), input);
-	return ensureArrayKeysDeep(result);
-}
-function setIfMissing(input, pathExpressionValues) {
-	let result = Object.entries(pathExpressionValues).flatMap(([pathExpression, replacementValue]) => Array.from(jsonMatch$1(input, pathExpression)).map((matchEntry) => ({
-		...matchEntry,
-		replacementValue
-	}))).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) {
-	let result = pathExpressions.flatMap((pathExpression) => Array.from(jsonMatch$1(input, pathExpression))).reverse().reduce((acc, { path }) => unsetDeep(acc, path), input);
-	return ensureArrayKeysDeep(result);
-}
-function insert(input, { items, ...insertPatch }) {
-	let operation, pathExpression;
-	if ("before" in insertPatch ? (operation = "before", pathExpression = insertPatch.before) : "after" in insertPatch ? (operation = "after", pathExpression = insertPatch.after) : "replace" in insertPatch && (operation = "replace", pathExpression = insertPatch.replace), !operation || typeof pathExpression != "string" || !pathExpression.length) return input;
-	let arrayPath = slicePath$1(pathExpression, 0, -1), positionPath = slicePath$1(pathExpression, -1), result = input;
-	for (let { path, value } of jsonMatch$1(input, arrayPath)) {
-		if (!Array.isArray(value)) continue;
-		let arr = value;
-		switch (operation) {
-			case "replace": {
-				let indexesToRemove = /* @__PURE__ */ new Set(), position = Infinity;
-				for (let itemMatch of jsonMatch$1(arr, positionPath)) {
-					if (itemMatch.path.length !== 1) continue;
-					let [segment] = itemMatch.path;
-					if (typeof segment == "string") continue;
-					let index;
-					typeof segment == "number" && (index = segment), typeof index == "number" && index < 0 && (index = arr.length + index), isKeySegment(segment) && (index = getIndexForKey$1(arr, segment._key)), typeof index == "number" && (index < 0 && (index = arr.length + index), indexesToRemove.add(index), index < position && (position = index));
-				}
-				if (position === Infinity) continue;
-				arr = arr.map((item, index) => ({
-					item,
-					index
-				})).filter(({ index }) => !indexesToRemove.has(index)).map(({ item }) => item), arr = [
-					...arr.slice(0, position),
-					...items,
-					...arr.slice(position, arr.length)
-				];
-				break;
-			}
-			case "before": {
-				let position = Infinity;
-				for (let itemMatch of jsonMatch$1(arr, positionPath)) {
-					if (itemMatch.path.length !== 1) continue;
-					let [segment] = itemMatch.path;
-					if (typeof segment == "string") continue;
-					let index;
-					typeof segment == "number" && (index = segment), typeof index == "number" && index < 0 && (index = arr.length + index), isKeySegment(segment) && (index = getIndexForKey$1(arr, segment._key)), typeof index == "number" && (index < 0 && (index = arr.length - index), index < position && (position = index));
-				}
-				if (position === Infinity) continue;
-				arr = [
-					...arr.slice(0, position),
-					...items,
-					...arr.slice(position, arr.length)
-				];
-				break;
-			}
-			case "after": {
-				let position = -Infinity;
-				for (let itemMatch of jsonMatch$1(arr, positionPath)) {
-					if (itemMatch.path.length !== 1) continue;
-					let [segment] = itemMatch.path;
-					if (typeof segment == "string") continue;
-					let index;
-					typeof segment == "number" && (index = segment), typeof index == "number" && index < 0 && (index = arr.length + index), isKeySegment(segment) && (index = getIndexForKey$1(arr, segment._key)), typeof index == "number" && index > position && (position = index);
-				}
-				if (position === -Infinity) continue;
-				arr = [
-					...arr.slice(0, position + 1),
-					...items,
-					...arr.slice(position + 1, arr.length)
-				];
-				break;
-			}
-			default: continue;
-		}
-		result = setDeep(result, path, arr);
-	}
-	return ensureArrayKeysDeep(result);
-}
-function inc(input, pathExpressionValues) {
-	let result = Object.entries(pathExpressionValues).flatMap(([pathExpression, valueToAdd]) => Array.from(jsonMatch$1(input, pathExpression)).map((matchEntry) => ({
-		...matchEntry,
-		valueToAdd
-	}))).filter((matchEntry) => typeof matchEntry.value == "number").reduce((acc, { path, value, valueToAdd }) => setDeep(acc, path, value + valueToAdd), input);
-	return ensureArrayKeysDeep(result);
-}
-function dec(input, pathExpressionValues) {
-	let result = inc(input, Object.fromEntries(Object.entries(pathExpressionValues).filter(([, value]) => typeof value == "number").map(([key, value]) => [key, -value])));
-	return ensureArrayKeysDeep(result);
-}
-function diffMatchPatch(input, pathExpressionValues) {
-	let result = Object.entries(pathExpressionValues).flatMap(([pathExpression, dmp]) => Array.from(jsonMatch$1(input, pathExpression)).map((m) => ({
-		...m,
-		dmp
-	}))).filter((i) => i.value !== void 0).map(({ path, value, dmp }) => {
-		if (typeof value != "string") throw Error(`Can't diff-match-patch \`${JSON.stringify(value)}\` at path \`${stringifyPath$1(path)}\`, because it is not a string`);
-		let [nextValue] = applyPatches(parsePatch(dmp), value, { allowExceedingIndices: !0 });
-		return {
-			path,
-			value: nextValue
-		};
-	}).reduce((acc, { path, value }) => setDeep(acc, path, value), input);
-	return ensureArrayKeysDeep(result);
-}
-function ifRevisionID(input, revisionId) {
-	let inputRev = typeof input == "object" && input && "_rev" in input && typeof input._rev == "string" ? input._rev : void 0;
-	if (typeof inputRev != "string") throw Error("Patch specified `ifRevisionID` but could not find document's revision ID.");
-	if (revisionId !== inputRev) throw Error(`Patch's \`ifRevisionID\` \`${revisionId}\` does not match document's revision ID \`${inputRev}\``);
-	return input;
-}
-function setDeep(input, path, value) {
-	let [currentSegment, ...restOfPath] = path;
-	if (currentSegment === void 0) return value;
-	if (typeof input != "object" || !input) {
-		if (typeof currentSegment == "string") return { [currentSegment]: setDeep(null, restOfPath, value) };
-		let index;
-		if (isKeySegment(currentSegment)) index = 0;
-		else if (typeof currentSegment == "number" && currentSegment >= 0) index = currentSegment;
-		else return input;
-		return [...Array.from({ length: index }).fill(null), setDeep(null, restOfPath, value)];
-	}
-	if (Array.isArray(input)) {
-		let index;
-		return isKeySegment(currentSegment) ? index = getIndexForKey$1(input, currentSegment._key) ?? input.length : typeof currentSegment == "number" && (index = currentSegment < 0 ? input.length + currentSegment : currentSegment), index === void 0 ? input : index in input ? input.map((nestedInput, i) => i === index ? setDeep(nestedInput, restOfPath, value) : nestedInput) : [
-			...input,
-			...Array.from({ length: index - input.length }).fill(null),
-			setDeep(null, restOfPath, value)
-		];
-	}
-	return typeof currentSegment == "object" ? input : currentSegment in input ? Object.fromEntries(Object.entries(input).map(([key, nestedInput]) => key === currentSegment ? [key, setDeep(nestedInput, restOfPath, value)] : [key, nestedInput])) : {
-		...input,
-		[currentSegment]: setDeep(null, restOfPath, value)
-	};
-}
-function unsetDeep(input, path) {
-	let [currentSegment, ...restOfPath] = path;
-	if (currentSegment === void 0 || typeof input != "object" || !input) return input;
-	let _segment;
-	if (isKeySegment(currentSegment) ? _segment = getIndexForKey$1(input, currentSegment._key) : (typeof currentSegment == "string" || typeof currentSegment == "number") && (_segment = currentSegment), _segment === void 0) return input;
-	let segment = _segment;
-	return typeof segment == "number" && Array.isArray(input) && (segment = segment < 0 ? input.length + segment : segment), segment in input ? restOfPath.length ? Array.isArray(input) ? input.map((nestedInput, index) => index === segment ? unsetDeep(nestedInput, restOfPath) : nestedInput) : Object.fromEntries(Object.entries(input).map(([key, value]) => key === segment ? [key, unsetDeep(value, restOfPath)] : [key, value])) : Array.isArray(input) ? input.filter((_nestedInput, index) => index !== segment) : Object.fromEntries(Object.entries(input).filter(([key]) => key !== segment.toString())) : input;
-}
-/**
-* Exposes the patch operations used by {@link processMutations}.
-*
-* @remarks
-* Property order determines execution order in {@link processMutations}:
-* `ifRevisionID`, `set`, `setIfMissing`, `unset`, `inc`, `dec`, `insert`,
-* then `diffMatchPatch`. Reordering the properties changes mutation results.
-* Freezes the collection to prevent callers from replacing the functions
-* used by the SDK's mutation evaluator.
-*
-* @see https://www.sanity.io/docs/http-mutations#5b4db1396e56
-*
-* @example
-* ```ts
-* const document = {items: [{_key: 'a', title: 'Before'}]}
-* const updated = patchOperations.set<typeof document>(document, {
-*   'items[_key=="a"].title': 'After',
-* })
-* ```
-*
-* @internal
-*/
-const patchOperations = Object.freeze({
-	ifRevisionID,
-	set,
-	setIfMissing,
-	unset,
-	inc,
-	dec,
-	insert,
-	diffMatchPatch
-});
-/**
-* Implements ID generation:
-*
-* A create mutation creates a new document. It takes the literal document
-* content as its argument. The rules for the new document's identifier are as
-* follows:
-*
-* - If the `_id` attribute is missing, then a new, random, unique ID is
-*   generated.
-* - If the `_id` attribute is present but ends with `.`, then it is used as a
-*   prefix for a new, random, unique ID.
-* - If the _id attribute is present, it is used as-is.
-*
-* [- source](https://www.sanity.io/docs/http-mutations#c732f27330a4)
-*/
-function getId(id) {
-	return !id || typeof id != "string" ? randomUuid() : id.endsWith(".") ? `${id}${randomUuid()}` : id;
-}
-function getDocumentIds(selection) {
-	if ("id" in selection) {
-		let ids = (Array.isArray(selection.id) ? selection.id : [selection.id]).filter((id) => typeof id == "string");
-		return Array.from(new Set(ids));
-	}
-	if ("query" in selection) throw Error("'query' in mutations is not supported.");
-	return [];
-}
-/**
-* Applies mutations to an in-memory set of Sanity documents.
-* Deleted documents remain in the returned set with a value of `null`.
-*
-* Include every document affected by `mutations` in `documents`, using `null`
-* for documents that do not exist.
-*
-* Returns `documents` itself when `mutations` is empty. Otherwise, returns a
-* shallow copy of that object. The result can reuse document objects and
-* nested objects from `documents`. Mutating a reused object through the
-* result also changes the input.
-*
-* Sets `_rev` to `transactionId` on created, replaced, and patched documents.
-* Uses `timestamp` for timestamps unless the mutation preserves them.
-* Ignores `merge` patches; `inc` and `dec` skip values that are not numbers.
-* Generates document IDs when omitted or ending in `.`.
-* Patch operations can generate missing array keys.
-*
-* Does not persist documents or run Content Lake's server validation.
-*
-* @throws If a selection uses a query, a `create` targets an existing document,
-* or a `patch` targets a document that does not exist.
-* @throws If a patch operation fails, including a revision check failure or
-* `diffMatchPatch` applied to a value other than a string or `undefined`.
-*
-* @internal
-*/
-function processMutations({ documents, mutations, transactionId, timestamp }) {
-	if (!mutations.length) return documents;
-	let dataset = { ...documents }, now = timestamp || (/* @__PURE__ */ new Date()).toISOString();
-	for (let mutation of mutations) if ("create" in mutation) {
-		let id = getId(mutation.create._id);
-		if (dataset[id]) throw Error(`Cannot create document with \`_id\` \`${id}\` because another document with the same ID already exists.`);
-		dataset[id] = {
-			_createdAt: now,
-			_updatedAt: now,
-			...mutation.create,
-			_rev: transactionId,
-			_id: id
-		};
-	} else if ("createOrReplace" in mutation) {
-		let id = getId(mutation.createOrReplace._id), prev = dataset[id];
-		dataset[id] = {
-			...mutation.createOrReplace,
-			_createdAt: prev?._createdAt || typeof mutation.createOrReplace._createdAt == "string" && mutation.createOrReplace._createdAt || now,
-			_updatedAt: prev ? now : typeof mutation.createOrReplace._updatedAt == "string" && mutation.createOrReplace._updatedAt || now,
-			_rev: transactionId,
-			_id: id
-		};
-	} else if ("createIfNotExists" in mutation) {
-		let id = getId(mutation.createIfNotExists._id);
-		if (dataset[id]) continue;
-		dataset[id] = {
-			_createdAt: now,
-			_updatedAt: now,
-			...mutation.createIfNotExists,
-			_rev: transactionId,
-			_id: id
-		};
-	} else if ("delete" in mutation) for (let id of getDocumentIds(mutation.delete)) dataset[id] = null;
-	else if ("patch" in mutation) {
-		let { patch } = mutation, patched = getDocumentIds(patch).map((id) => {
-			if (!dataset[id]) throw Error(`Cannot patch document with ID \`${id}\` because it was not found.`);
-			return Object.entries(patchOperations).reduce((acc, [type, operation]) => patch[type] ? operation(acc, patch[type]) : acc, dataset[id]);
-		});
-		for (let result of patched) dataset[result._id] = {
-			...result,
-			_rev: transactionId,
-			_updatedAt: now
-		};
-	}
-	return dataset;
-}
 var OutOfSyncError = class extends Error {
 	/**
 	* Attach state to the error for debugging/reporting
@@ -2282,168 +1935,6 @@ var MultiKeyWeakMap = class MultiKeyWeakMap {
 		this.#setDeep(arrangedKeys, this.#rootMap, value);
 	}
 };
-function checkGrant(grantExpr, document, identity) {
-	let value = evaluateSync(grantExpr, {
-		params: { document },
-		identity
-	});
-	return value.type === "boolean" && value.data;
-}
-/**
-* Thrown when a precondition for an action failed.
-*/
-var ActionError = class extends Error {
-	documentId;
-	transactionId;
-	constructor(options) {
-		super(options.message), Object.assign(this, options);
-	}
-}, PermissionActionError = class extends ActionError {};
-/**
-* Creates a `processMutations` wrapper that surfaces application failures as
-* `ActionError`s when the caller asked to preserve their patch operations.
-* With preserved operations, patches can legitimately fail to apply (e.g.
-* re-applied onto a diverged document during a rebase), so wrapping lets a
-* rebase skip the transaction instead of failing the store. Without
-* `preserveOperations`, errors are rethrown untouched.
-*/
-function createMutationApplier(options) {
-	let { 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;
-		}
-	};
-}
-/**
-* Re-applies the operational intent of user-supplied `inc`/`dec` patches to a
-* set of snapshot-diffed patches.
-*
-* The outgoing patches sent to Content Lake are re-derived by diffing the
-* base document before and after the user's patches were applied. That diff
-* collapses an `inc` into a `set` of the resulting number, which turns
-* concurrent increments from different clients into last-write-wins. This
-* helper finds diffed `set` operations that are exactly explained by the
-* user's `inc`/`dec` operations and swaps them back, so the server applies
-* the increment against whatever value is current at commit time.
-*
-* A `set` is only swapped when its value equals the base value plus the
-* accumulated user deltas for that exact path; anything else (e.g. an `inc`
-* combined with a `set` of the same field) keeps the diffed `set`.
-*
-* Content Lake fails the whole transaction when `inc`/`dec` targets a missing
-* path (unlike `set`, which always succeeds). To avoid turning a concurrent
-* field removal into a transaction revert, the emitted patch seeds the target
-* with a `setIfMissing` of the base value; the server executes `setIfMissing`
-* before `inc`/`dec` within a single patch, so a concurrently removed field
-* degrades to the same result the diffed `set` would have produced. A path
-* into a concurrently removed keyed array item can still fail the
-* transaction (`setIfMissing` cannot create array items); the transaction is
-* then reverted and reported, which is preferable to silently resurrecting
-* the item.
-*/
-function preserveNumericOperations(baseBefore, userPatches, diffedPatches) {
-	if (!baseBefore || !userPatches?.length) return diffedPatches;
-	let targets = /* @__PURE__ */ new Map();
-	for (let patch of userPatches) for (let [op, sign] of [["inc", 1], ["dec", -1]]) {
-		let record = patch[op];
-		if (record) {
-			for (let [pathExpression, amount] of Object.entries(record)) if (typeof amount == "number") for (let match of jsonMatch$1(baseBefore, pathExpression)) {
-				let path = stringifyPath$1(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;
-	let preserved = /* @__PURE__ */ new Map(), next = diffedPatches.flatMap((patch) => {
-		if (!patch.set) return [patch];
-		let keptSet = {};
-		for (let [path, value] of Object.entries(patch.set)) {
-			let 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];
-		let { set: _set, ...rest } = patch, withKept = Object.keys(keptSet).length ? {
-			...rest,
-			set: keptSet
-		} : rest;
-		return Object.keys(withKept).length ? [withKept] : [];
-	});
-	if (!preserved.size) return next;
-	let setIfMissing = {}, inc = {}, dec = {};
-	for (let [path, { delta, baseValue }] of preserved) setIfMissing[path] = baseValue, delta >= 0 ? inc[path] = delta : dec[path] = -delta;
-	return [...next, {
-		setIfMissing,
-		...Object.keys(inc).length && { inc },
-		...Object.keys(dec).length && { dec }
-	}];
-}
-/**
-* Shared logic for applying user-provided patches to a single document that
-* is identified by an exact ID (no draft/published wrapping). Used by the
-* liveEdit branch of `document.edit` and by `release.edit`.
-*
-* Returns the updated base + working sets, plus the diffed patches in both
-* raw and mutation form so the caller can decide what to send to the server.
-*/
-function applySingleDocPatch({ base: initialBase, working: initialWorking, documentId, patches, transactionId, timestamp, grants, identity, notFoundMessage = "Cannot edit document because it does not exist.", permissionMessage = `You do not have permission to edit document "${documentId}".`, preserveOperations }) {
-	let base = initialBase, working = initialWorking, userPatches = patches?.map((patch) => ({ patch: {
-		id: documentId,
-		...patch
-	} }));
-	if (!userPatches?.length) return {
-		base,
-		working,
-		diffedPatches: [],
-		workingMutations: []
-	};
-	if (!working[documentId] || !base[documentId]) throw new ActionError({
-		documentId,
-		transactionId,
-		message: notFoundMessage
-	});
-	let applyMutations = createMutationApplier({
-		documentId,
-		transactionId,
-		timestamp,
-		preserveOperations
-	}), baseBefore = base[documentId];
-	base = applyMutations(base, userPatches, "base");
-	let 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
-	});
-	let workingMutations = diffedPatches.map((patch) => ({ patch: {
-		id: documentId,
-		...patch
-	} }));
-	return working = applyMutations(working, workingMutations, "working"), {
-		base,
-		working,
-		diffedPatches,
-		workingMutations
-	};
-}
 function createGrantsLookup(datasetAcl) {
 	let filtersByGrant = {
 		create: /* @__PURE__ */ new Set(),
@@ -3006,10 +2497,10 @@ function handleReleaseDelete(action, ctx) {
 	};
 }
 function handleReleaseEdit(action, ctx) {
-	let { transactionId, timestamp, grants, outgoingActions, outgoingMutations, identity } = ctx, { base, working } = ctx, result = applySingleDocPatch({
+	let { transactionId, timestamp, grants, outgoingActions, outgoingMutations, identity } = ctx, { base, working } = ctx, releaseDocumentId = getReleaseDocumentId(action.releaseId), result = applySingleDocPatch({
 		base,
 		working,
-		documentId: getReleaseDocumentId(action.releaseId),
+		documentId: releaseDocumentId,
 		patches: [action.patch],
 		transactionId,
 		timestamp,