@portabletext/plugin-sdk-value 7.2.0 → 7.2.2

package/dist/index.js

@@ -1,1038 +1,1032 @@
 import { c } from "react/compiler-runtime";
-import { useEditDocument, useSanityInstance, useApplyDocumentActions, getDocumentState, subscribeDocumentEvents, editDocument, useReportPresence, usePresenceForDocument } from "@sanity/sdk-react";
+import { editDocument, getDocumentState, subscribeDocumentEvents, useApplyDocumentActions, useEditDocument, usePresenceForDocument, useReportPresence, useSanityInstance } from "@sanity/sdk-react";
 import { useState } from "react";
-import { useEditor, useEditorSelector, PortableTextEditable } from "@portabletext/editor";
+import { PortableTextEditable, useEditor, useEditorSelector } from "@portabletext/editor";
 import { getSelection } from "@portabletext/editor/selectors";
 import { isEqualSelections } from "@portabletext/editor/utils";
-import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { applyAll } from "@portabletext/patches";
 import { diffValue } from "@sanity/diff-patch";
 import { parsePath } from "@sanity/json-match";
 import { useActorRef } from "@xstate/react";
 import { fromCallback, setup } from "xstate";
 import rawDebug from "debug";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+/**
+* Reduces a selection to a caret at its focus point.
+*
+* Presence answers where someone is, so decorating their whole selection would
+* highlight text the local user never selected. The Studio collapses the same
+* way, which keeps the two consistent when both are open on a document.
+*
+* @public
+*/
 function collapseToCaret(selection) {
-  return selection === null ? null : {
-    anchor: selection.focus,
-    focus: selection.focus
-  };
+	return selection === null ? null : {
+		anchor: selection.focus,
+		focus: selection.focus
+	};
 }
+/**
+* Where one remote caret should be drawn.
+*
+* A caret the local editor has moved keeps that moved position for as long as
+* the participant keeps reporting the same selection. A changed report wins,
+* because the participant has actually moved.
+*
+* @public
+*/
 function resolveCursorSelection(cursor, override) {
-  return override && isEqualSelections(override.reported, cursor.selection) ? override.current : collapseToCaret(cursor.selection);
+	return override && isEqualSelections(override.reported, cursor.selection) ? override.current : collapseToCaret(cursor.selection);
 }
+/**
+* Records where the editor moved a caret to.
+*
+* Overrides for sessions that are no longer present are dropped, so a long
+* editing session does not accumulate one entry per participant who ever
+* visited. Returns the map untouched when nothing changed.
+*
+* @public
+*/
 function recordCursorMove(overrides, cursors, cursor, selection) {
-  const moved = collapseToCaret(selection), existing = overrides.get(cursor.sessionId), alreadyRecorded = existing !== void 0 && isEqualSelections(existing.reported, cursor.selection) && isEqualSelections(existing.current, moved), live = new Set(cursors.map((candidate) => candidate.sessionId)), staleKeys = [...overrides.keys()].filter((key) => !live.has(key));
-  if (alreadyRecorded && staleKeys.length === 0)
-    return overrides;
-  const next = new Map(overrides);
-  for (const key of staleKeys)
-    next.delete(key);
-  return next.set(cursor.sessionId, {
-    reported: cursor.selection,
-    current: moved
-  }), next;
+	let moved = collapseToCaret(selection), existing = overrides.get(cursor.sessionId), alreadyRecorded = existing !== void 0 && isEqualSelections(existing.reported, cursor.selection) && isEqualSelections(existing.current, moved), live = new Set(cursors.map((candidate) => candidate.sessionId)), staleKeys = [...overrides.keys()].filter((key) => !live.has(key));
+	if (alreadyRecorded && staleKeys.length === 0) return overrides;
+	let next = new Map(overrides);
+	for (let key of staleKeys) next.delete(key);
+	return next.set(cursor.sessionId, {
+		reported: cursor.selection,
+		current: moved
+	}), next;
 }
+/**
+* Maps remote cursors to range decorations for
+* `<PortableTextEditable rangeDecorations={...} />`.
+*
+* Participants with no caret to draw are skipped, so someone who clears their
+* selection stops drawing without being treated as having left.
+*
+* @public
+*/
 function toRangeDecorations(options) {
-  const {
-    cursors,
-    overrides,
-    renderCursor,
-    onCursorMoved
-  } = options, decorations = [];
-  for (const cursor of cursors) {
-    const selection = resolveCursorSelection(cursor, overrides.get(cursor.sessionId));
-    selection !== null && decorations.push({
-      component: renderCursor(cursor),
-      selection,
-      payload: {
-        sessionId: cursor.sessionId
-      },
-      onMoved: onCursorMoved ? (details) => onCursorMoved(cursor, details.newSelection) : void 0
-    });
-  }
-  return decorations;
+	let { cursors, overrides, renderCursor, onCursorMoved } = options, decorations = [];
+	for (let cursor of cursors) {
+		let selection = resolveCursorSelection(cursor, overrides.get(cursor.sessionId));
+		selection !== null && decorations.push({
+			component: renderCursor(cursor),
+			selection,
+			payload: { sessionId: cursor.sessionId },
+			onMoved: onCursorMoved ? (details) => onCursorMoved(cursor, details.newSelection) : void 0
+		});
+	}
+	return decorations;
 }
+/**
+* The local user's selection, deduped by value.
+*
+* The editor produces a fresh selection object on every snapshot change, so
+* subscribing to it directly would report presence far more often than the
+* caret actually moves.
+*
+* @public
+*/
 function useLocalSelection() {
-  const editor = useEditor();
-  return useEditorSelector(editor, getSelection, isEqualSelections);
+	let editor = useEditor();
+	return useEditorSelector(editor, getSelection, isEqualSelections);
 }
+/**
+* Turns remote cursors into range decorations, keeping each caret anchored as
+* the local user edits.
+*
+* Knows nothing about Sanity or the SDK, so it can also drive carets from
+* another source or from a test fixture. `useSDKPresenceCursors` is the version
+* wired to SDK presence.
+*
+* @public
+*/
 function useRemoteCursors(options) {
-  const $ = c(7), {
-    cursors,
-    renderCursor
-  } = options, [overrides, setOverrides] = useState(EMPTY_OVERRIDES);
-  let t0;
-  $[0] !== cursors ? (t0 = (cursor, selection) => {
-    setOverrides((previous) => recordCursorMove(previous, cursors, cursor, selection));
-  }, $[0] = cursors, $[1] = t0) : t0 = $[1];
-  const onCursorMoved = t0;
-  let t1;
-  return $[2] !== cursors || $[3] !== onCursorMoved || $[4] !== overrides || $[5] !== renderCursor ? (t1 = toRangeDecorations({
-    cursors,
-    overrides,
-    renderCursor,
-    onCursorMoved
-  }), $[2] = cursors, $[3] = onCursorMoved, $[4] = overrides, $[5] = renderCursor, $[6] = t1) : t1 = $[6], t1;
+	let $ = c(7), { cursors, renderCursor } = options, [overrides, setOverrides] = useState(EMPTY_OVERRIDES), t0;
+	$[0] === cursors ? t0 = $[1] : (t0 = (cursor, selection) => {
+		setOverrides((previous) => recordCursorMove(previous, cursors, cursor, selection));
+	}, $[0] = cursors, $[1] = t0);
+	let onCursorMoved = t0, t1;
+	return $[2] !== cursors || $[3] !== onCursorMoved || $[4] !== overrides || $[5] !== renderCursor ? (t1 = toRangeDecorations({
+		cursors,
+		overrides,
+		renderCursor,
+		onCursorMoved
+	}), $[2] = cursors, $[3] = onCursorMoved, $[4] = overrides, $[5] = renderCursor, $[6] = t1) : t1 = $[6], t1;
 }
 const EMPTY_OVERRIDES = /* @__PURE__ */ new Map(), rootName = "pte:plugin-sdk-value:";
 function createDebugger(name) {
-  const namespace = `${rootName}${name}`;
-  return rawDebug && rawDebug.enabled(namespace) ? rawDebug(namespace) : rawDebug(rootName);
+	let namespace = `${rootName}${name}`;
+	return rawDebug && rawDebug.enabled(namespace) ? rawDebug(namespace) : rawDebug(rootName);
 }
 const debug = {
-  mutation: createDebugger("mutation"),
-  push: createDebugger("push"),
-  remote: createDebugger("remote"),
-  repair: createDebugger("repair")
+	mutation: createDebugger("mutation"),
+	push: createDebugger("push"),
+	remote: createDebugger("remote"),
+	repair: createDebugger("repair")
 }, ARRAYIFY_ERROR_MESSAGE = "Unexpected path format from diffValue output. Please report this issue.";
 function* getSegments(node) {
-  node.base && (yield* getSegments(node.base)), node.segment.type !== "This" && (yield node.segment);
+	node.base && (yield* getSegments(node.base)), node.segment.type !== "This" && (yield node.segment);
 }
 function isKeyPath(node) {
-  return node.type !== "Path" || node.base || node.recursive || node.segment.type !== "Identifier" ? !1 : node.segment.name === "_key";
+	return node.type !== "Path" || node.base || node.recursive || node.segment.type !== "Identifier" ? !1 : node.segment.name === "_key";
 }
 function arrayifyPath(pathExpr) {
-  const node = parsePath(pathExpr);
-  if (!node)
-    return [];
-  if (node.type !== "Path")
-    throw new Error(ARRAYIFY_ERROR_MESSAGE);
-  return Array.from(getSegments(node)).map((segment) => {
-    if (segment.type === "Identifier")
-      return segment.name;
-    if (segment.type !== "Subscript")
-      throw new Error(ARRAYIFY_ERROR_MESSAGE);
-    if (segment.elements.length !== 1)
-      throw new Error(ARRAYIFY_ERROR_MESSAGE);
-    const [element] = segment.elements;
-    if (element.type === "Number")
-      return element.value;
-    if (element.type !== "Comparison")
-      throw new Error(ARRAYIFY_ERROR_MESSAGE);
-    if (element.operator !== "==")
-      throw new Error(ARRAYIFY_ERROR_MESSAGE);
-    const keyPathNode = [element.left, element.right].find(isKeyPath);
-    if (!keyPathNode)
-      throw new Error(ARRAYIFY_ERROR_MESSAGE);
-    const other = element.left === keyPathNode ? element.right : element.left;
-    if (other.type !== "String")
-      throw new Error(ARRAYIFY_ERROR_MESSAGE);
-    return {
-      _key: other.value
-    };
-  });
+	let node = parsePath(pathExpr);
+	if (!node) return [];
+	if (node.type !== "Path") throw Error(ARRAYIFY_ERROR_MESSAGE);
+	return Array.from(getSegments(node)).map((segment) => {
+		if (segment.type === "Identifier") return segment.name;
+		if (segment.type !== "Subscript" || segment.elements.length !== 1) throw Error(ARRAYIFY_ERROR_MESSAGE);
+		let [element] = segment.elements;
+		if (element.type === "Number") return element.value;
+		if (element.type !== "Comparison" || element.operator !== "==") throw Error(ARRAYIFY_ERROR_MESSAGE);
+		let keyPathNode = [element.left, element.right].find(isKeyPath);
+		if (!keyPathNode) throw Error(ARRAYIFY_ERROR_MESSAGE);
+		let other = element.left === keyPathNode ? element.right : element.left;
+		if (other.type !== "String") throw Error(ARRAYIFY_ERROR_MESSAGE);
+		return { _key: other.value };
+	});
 }
 function convertPatches(patches) {
-  return patches.flatMap((p) => Object.entries(p).flatMap(([type, values]) => {
-    const origin = "remote";
-    switch (type) {
-      case "set":
-      case "setIfMissing":
-      case "diffMatchPatch":
-      case "inc":
-      case "dec":
-        return Object.entries(values).map(([pathExpr, value]) => ({
-          type,
-          value,
-          origin,
-          path: arrayifyPath(pathExpr)
-        }));
-      case "unset":
-        return Array.isArray(values) ? values.map(arrayifyPath).map((path) => ({
-          type,
-          origin,
-          path
-        })) : [];
-      case "insert": {
-        const {
-          items,
-          ...rest
-        } = values, position = Object.keys(rest).at(0);
-        if (!position)
-          return [];
-        const pathExpr = rest[position];
-        return [{
-          type,
-          origin,
-          position,
-          path: arrayifyPath(pathExpr),
-          items
-        }];
-      }
-      default:
-        return [];
-    }
-  }));
+	return patches.flatMap((p) => Object.entries(p).flatMap(([type, values]) => {
+		let origin = "remote";
+		switch (type) {
+			case "set":
+			case "setIfMissing":
+			case "diffMatchPatch":
+			case "inc":
+			case "dec": return Object.entries(values).map(([pathExpr, value]) => ({
+				type,
+				value,
+				origin,
+				path: arrayifyPath(pathExpr)
+			}));
+			case "unset": return Array.isArray(values) ? values.map(arrayifyPath).map((path) => ({
+				type,
+				origin,
+				path
+			})) : [];
+			case "insert": {
+				let { items, ...rest } = values, position = Object.keys(rest).at(0);
+				if (!position) return [];
+				let pathExpr = rest[position];
+				return [{
+					type,
+					origin,
+					position,
+					path: arrayifyPath(pathExpr),
+					items
+				}];
+			}
+			default: return [];
+		}
+	}));
 }
 const STRINGIFY_ERROR_MESSAGE = "Unable to convert an editor patch path to a Sanity path expression.";
+/**
+* Converts a Portable Text Editor patch path (an array of segments) into a
+* Sanity json-match path expression. The inverse of `arrayifyPath`.
+*
+* @internal
+*/
 function stringifyPatchPath(path) {
-  let result = "";
-  for (const segment of path)
-    if (typeof segment == "string")
-      result = result === "" ? segment : `${result}.${segment}`;
-    else if (typeof segment == "number")
-      result = `${result}[${segment}]`;
-    else if (typeof segment == "object" && segment !== null && "_key" in segment)
-      result = `${result}[_key=="${segment._key}"]`;
-    else
-      throw new Error(STRINGIFY_ERROR_MESSAGE);
-  return result;
+	let result = "";
+	for (let segment of path) if (typeof segment == "string") result = result === "" ? segment : `${result}.${segment}`;
+	else if (typeof segment == "number") result = `${result}[${segment}]`;
+	else if (typeof segment == "object" && segment && "_key" in segment) result = `${result}[_key=="${segment._key}"]`;
+	else throw Error(STRINGIFY_ERROR_MESSAGE);
+	return result;
 }
 function prefixPathExpression(prefix, expression) {
-  return expression === "" ? prefix : expression.startsWith("[") ? `${prefix}${expression}` : `${prefix}.${expression}`;
+	return expression === "" ? prefix : expression.startsWith("[") ? `${prefix}${expression}` : `${prefix}.${expression}`;
 }
+/**
+* Converts Portable Text Editor patches into Sanity patch operations rooted
+* at the given document field path. Throws if a patch cannot be converted;
+* callers should fall back to pushing the whole value.
+*
+* @internal
+*/
 function convertPatchesToSanity(patches, options) {
-  return patches.map((patch) => {
-    const pathExpression = prefixPathExpression(options.prefix, stringifyPatchPath(patch.path));
-    switch (patch.type) {
-      case "set":
-        return {
-          set: {
-            [pathExpression]: patch.value
-          }
-        };
-      case "setIfMissing":
-        return {
-          setIfMissing: {
-            [pathExpression]: patch.value
-          }
-        };
-      case "unset":
-        return patch.path.length === 0 ? {
-          set: {
-            [pathExpression]: []
-          }
-        } : {
-          unset: [pathExpression]
-        };
-      case "diffMatchPatch":
-        return {
-          diffMatchPatch: {
-            [pathExpression]: patch.value
-          }
-        };
-      case "inc":
-        return {
-          inc: {
-            [pathExpression]: patch.value
-          }
-        };
-      case "dec":
-        return {
-          dec: {
-            [pathExpression]: patch.value
-          }
-        };
-      case "insert":
-        return {
-          insert: {
-            [patch.position]: pathExpression,
-            items: patch.items
-          }
-        };
-      default:
-        throw new Error(STRINGIFY_ERROR_MESSAGE);
-    }
-  });
+	return patches.map((patch) => {
+		let pathExpression = prefixPathExpression(options.prefix, stringifyPatchPath(patch.path));
+		switch (patch.type) {
+			case "set": return { set: { [pathExpression]: patch.value } };
+			case "setIfMissing": return { setIfMissing: { [pathExpression]: patch.value } };
+			case "unset": return patch.path.length === 0 ? { set: { [pathExpression]: [] } } : { unset: [pathExpression] };
+			case "diffMatchPatch": return { diffMatchPatch: { [pathExpression]: patch.value } };
+			case "inc": return { inc: { [pathExpression]: patch.value } };
+			case "dec": return { dec: { [pathExpression]: patch.value } };
+			case "insert": return { insert: {
+				[patch.position]: pathExpression,
+				items: patch.items
+			} };
+			default: throw Error(STRINGIFY_ERROR_MESSAGE);
+		}
+	});
 }
 function segmentsEqual(a, b) {
-  return typeof a == "string" || typeof a == "number" ? a === b : typeof b == "string" || typeof b == "number" || Array.isArray(a) || Array.isArray(b) ? !1 : a._key === b._key;
+	return typeof a == "string" || typeof a == "number" ? a === b : typeof b == "string" || typeof b == "number" || Array.isArray(a) || Array.isArray(b) ? !1 : a._key === b._key;
 }
 function pathsEqual(a, b) {
-  return a.length === b.length && a.every((segment, index) => segmentsEqual(segment, b[index]));
+	return a.length === b.length && a.every((segment, index) => segmentsEqual(segment, b[index]));
 }
+/**
+* The editor engine can only resolve keyed/indexed segments against the
+* root block array and (possibly nested) `children` arrays. Operations
+* that address items of any other array, e.g. a block's `markDefs` or a
+* span's `marks`, misapply. When a patch path enters such a sidecar
+* array, this returns the path of the array itself so callers can fall
+* back to replacing the whole property; returns `null` for paths the
+* engine can apply.
+*
+* @internal
+*/
 function findSidecarArrayPath(path) {
-  let expectNode = !0;
-  for (let index = 0; index < path.length; index++) {
-    const segment = path[index];
-    if (typeof segment == "string")
-      expectNode = segment === "children";
-    else {
-      if (!expectNode)
-        return path.slice(0, index);
-      expectNode = !1;
-    }
-  }
-  return null;
+	let expectNode = !0;
+	for (let index = 0; index < path.length; index++) {
+		let segment = path[index];
+		if (typeof segment == "string") expectNode = segment === "children";
+		else {
+			if (!expectNode) return path.slice(0, index);
+			expectNode = !1;
+		}
+	}
+	return null;
 }
 function getValueAtPath(value, path) {
-  let current = value;
-  for (const segment of path) {
-    if (current == null)
-      return;
-    if (typeof segment == "number") {
-      if (!Array.isArray(current))
-        return;
-      current = current[segment < 0 ? current.length + segment : segment];
-    } else if (typeof segment == "string") {
-      if (typeof current != "object" || Array.isArray(current))
-        return;
-      current = current[segment];
-    } else {
-      if (Array.isArray(segment) || !Array.isArray(current))
-        return;
-      current = current.find((item) => typeof item == "object" && item !== null && !Array.isArray(item) && item._key === segment._key);
-    }
-  }
-  return current;
+	let current = value;
+	for (let segment of path) {
+		if (current == null) return;
+		if (typeof segment == "number") {
+			if (!Array.isArray(current)) return;
+			current = current[segment < 0 ? current.length + segment : segment];
+		} else if (typeof segment == "string") {
+			if (typeof current != "object" || Array.isArray(current)) return;
+			current = current[segment];
+		} else if (Array.isArray(segment)) return;
+		else {
+			if (!Array.isArray(current)) return;
+			current = current.find((item) => typeof item == "object" && !!item && !Array.isArray(item) && item._key === segment._key);
+		}
+	}
+	return current;
 }
+/**
+* Converts a target-value diff into patches the editor engine can apply.
+* Patches addressing items inside sidecar arrays are coalesced into whole
+* `set`s (or `unset`s) of the owning property, taken from the target
+* value.
+*
+* @internal
+*/
 function toEngineSafePatches(patches, targetValue) {
-  const safe = [], sidecarPaths = [];
-  for (const patch of patches) {
-    const sidecarPath = findSidecarArrayPath(patch.path);
-    if (!sidecarPath) {
-      safe.push(patch);
-      continue;
-    }
-    sidecarPaths.some((existing) => pathsEqual(existing, sidecarPath)) || sidecarPaths.push(sidecarPath);
-  }
-  for (const sidecarPath of sidecarPaths) {
-    const value = getValueAtPath(targetValue, sidecarPath);
-    safe.push(value === void 0 ? {
-      type: "unset",
-      path: sidecarPath,
-      origin: "remote"
-    } : {
-      type: "set",
-      path: sidecarPath,
-      value,
-      origin: "remote"
-    });
-  }
-  return safe;
+	let safe = [], sidecarPaths = [];
+	for (let patch of patches) {
+		let sidecarPath = findSidecarArrayPath(patch.path);
+		if (!sidecarPath) {
+			safe.push(patch);
+			continue;
+		}
+		sidecarPaths.some((existing) => pathsEqual(existing, sidecarPath)) || sidecarPaths.push(sidecarPath);
+	}
+	for (let sidecarPath of sidecarPaths) {
+		let value = getValueAtPath(targetValue, sidecarPath);
+		safe.push(value === void 0 ? {
+			type: "unset",
+			path: sidecarPath,
+			origin: "remote"
+		} : {
+			type: "set",
+			path: sidecarPath,
+			value,
+			origin: "remote"
+		});
+	}
+	return safe;
 }
+/**
+* Drops insert items whose `_key` is absent from the remote value. A text
+* paste can stage a temporary span and remove it again within the same
+* transaction; applying the insert without the cleanup would flash the
+* staged content. Callers must only run this once the store value reflects
+* the transaction the patches belong to (see `'apply remote patches'`),
+* otherwise every legitimately new node would be dropped.
+*/
 function filterInsertsMissingFromRemoteValue(patches, remoteValue) {
-  return patches.flatMap((patch) => {
-    if (patch.type !== "insert")
-      return [patch];
-    const parentValue = getValueAtPath(remoteValue, patch.path.slice(0, -1));
-    if (!Array.isArray(parentValue))
-      return [patch];
-    const items = patch.items.filter((item) => {
-      const itemKey = getKey(item);
-      return itemKey ? parentValue.some((candidate) => getKey(candidate) === itemKey) : !0;
-    });
-    return items.length > 0 ? [{
-      ...patch,
-      items
-    }] : [];
-  });
+	return patches.flatMap((patch) => {
+		if (patch.type !== "insert") return [patch];
+		let parentValue = getValueAtPath(remoteValue, patch.path.slice(0, -1));
+		if (!Array.isArray(parentValue)) return [patch];
+		let items = patch.items.filter((item) => {
+			let itemKey = getKey(item);
+			return !itemKey || parentValue.some((candidate) => getKey(candidate) === itemKey);
+		});
+		return items.length > 0 ? [{
+			...patch,
+			items
+		}] : [];
+	});
 }
 function getKey(value) {
-  if (typeof value != "object" || value === null || Array.isArray(value))
-    return;
-  const key = value._key;
-  return typeof key == "string" ? key : void 0;
+	if (typeof value != "object" || !value || Array.isArray(value)) return;
+	let key = value._key;
+	return typeof key == "string" ? key : void 0;
 }
+/**
+* The editor writes `markDefs` as whole-array `set`s. Two clients
+* formatting the same block concurrently then overwrite each other's
+* arrays at the server (last writer wins) while both clients' span
+* `marks` references survive, stranding marks without definitions.
+* Outgoing `markDefs` sets are therefore decomposed into item-level
+* operations against the store (server truth): new definitions insert,
+* changed definitions set by key, and removed definitions unset by key,
+* except definitions the store's own spans still reference (a diverged
+* client's normalizer prunes those spuriously; a later, converged flush
+* removes them for real). Item-keyed operations merge at the server
+* instead of overwriting.
+*
+* @internal
+*/
 function toMergeableMarkDefsPatches(patches, getCurrentValue) {
-  return patches.flatMap((patch) => {
-    if (patch.type !== "set" || patch.path.at(-1) !== "markDefs" || !Array.isArray(patch.value))
-      return [patch];
-    const currentValue = getCurrentValue();
-    if (!currentValue)
-      return [patch];
-    const root = currentValue, storeMarkDefs = getValueAtPath(root, patch.path), storeBlock = getValueAtPath(root, patch.path.slice(0, -1));
-    if (!Array.isArray(storeMarkDefs) || typeof storeBlock != "object" || storeBlock === null)
-      return [patch];
-    const local = patch.value, store = storeMarkDefs;
-    if (local.some((item) => item._key === void 0))
-      return [patch];
-    const referencedKeys = new Set((storeBlock.children ?? []).flatMap((child) => child.marks ?? [])), storeByKey = new Map(store.map((item) => [item._key, item])), localKeys = new Set(local.map((item) => item._key)), origin = patch.origin, ops = [], inserted = local.filter((item) => !storeByKey.has(item._key));
-    if (inserted.length > 0) {
-      for (const item of inserted)
-        item._key !== void 0 && ops.push({
-          type: "unset",
-          origin,
-          path: [...patch.path, {
-            _key: item._key
-          }]
-        });
-      ops.push({
-        type: "insert",
-        origin,
-        position: "after",
-        path: [...patch.path, -1],
-        items: inserted
-      });
-    }
-    for (const item of local) {
-      const existing = storeByKey.get(item._key);
-      existing && JSON.stringify(existing) !== JSON.stringify(item) && ops.push({
-        type: "set",
-        origin,
-        path: [...patch.path, {
-          _key: item._key
-        }],
-        value: item
-      });
-    }
-    for (const item of store)
-      item._key !== void 0 && !localKeys.has(item._key) && !referencedKeys.has(item._key) && ops.push({
-        type: "unset",
-        origin,
-        path: [...patch.path, {
-          _key: item._key
-        }]
-      });
-    return ops;
-  });
+	return patches.flatMap((patch) => {
+		if (patch.type !== "set" || patch.path.at(-1) !== "markDefs" || !Array.isArray(patch.value)) return [patch];
+		let currentValue = getCurrentValue();
+		if (!currentValue) return [patch];
+		let root = currentValue, storeMarkDefs = getValueAtPath(root, patch.path), storeBlock = getValueAtPath(root, patch.path.slice(0, -1));
+		if (!Array.isArray(storeMarkDefs) || typeof storeBlock != "object" || !storeBlock) return [patch];
+		let local = patch.value, store = storeMarkDefs;
+		if (local.some((item) => item._key === void 0)) return [patch];
+		let referencedKeys = new Set((storeBlock.children ?? []).flatMap((child) => child.marks ?? [])), storeByKey = new Map(store.map((item) => [item._key, item])), localKeys = new Set(local.map((item) => item._key)), origin = patch.origin, ops = [], inserted = local.filter((item) => !storeByKey.has(item._key));
+		if (inserted.length > 0) {
+			for (let item of inserted) item._key !== void 0 && ops.push({
+				type: "unset",
+				origin,
+				path: [...patch.path, { _key: item._key }]
+			});
+			ops.push({
+				type: "insert",
+				origin,
+				position: "after",
+				path: [...patch.path, -1],
+				items: inserted
+			});
+		}
+		for (let item of local) {
+			let existing = storeByKey.get(item._key);
+			existing && JSON.stringify(existing) !== JSON.stringify(item) && ops.push({
+				type: "set",
+				origin,
+				path: [...patch.path, { _key: item._key }],
+				value: item
+			});
+		}
+		for (let item of store) item._key !== void 0 && !localKeys.has(item._key) && !referencedKeys.has(item._key) && ops.push({
+			type: "unset",
+			origin,
+			path: [...patch.path, { _key: item._key }]
+		});
+		return ops;
+	});
 }
+/**
+* Whether a remote patch can resolve against the given editor value.
+* Concurrent edits routinely produce operations addressing nodes another
+* client has already removed or not yet created; sending those into the
+* engine fails loudly (console errors) before being skipped. Callers drop
+* unresolvable patches up front and rely on the follow-up repair sync to
+* converge instead.
+*
+* @internal
+*/
 function canApplyToValue(patch, value) {
-  if (!value)
-    return !0;
-  const root = value;
-  switch (patch.type) {
-    // unset needs the node itself; insert needs the sibling at `path`;
-    // diffMatchPatch needs the existing string
-    case "unset":
-    case "insert":
-    case "diffMatchPatch":
-      return getValueAtPath(root, patch.path) !== void 0;
-    // set creates its target property, so only the parent must resolve
-    case "set":
-      return patch.path.length === 0 || getValueAtPath(root, patch.path.slice(0, -1)) !== void 0;
-    default:
-      return !0;
-  }
+	if (!value) return !0;
+	let root = value;
+	switch (patch.type) {
+		case "unset":
+		case "insert":
+		case "diffMatchPatch": return getValueAtPath(root, patch.path) !== void 0;
+		case "set": return patch.path.length === 0 || getValueAtPath(root, patch.path.slice(0, -1)) !== void 0;
+		default: return !0;
+	}
 }
+/**
+* Filters a patch batch down to the patches that can resolve (see
+* `canApplyToValue`), checking each patch against the value as it stands
+* after the preceding patches applied. A transaction routinely inserts a
+* node and then addresses it, e.g. a span split followed by a `marks` set
+* on the new span, so checking every patch against the starting value
+* would drop valid operations.
+*/
 function filterResolvablePatches(patches, value) {
-  let projected = value;
-  const resolvable = [];
-  for (const patch of patches)
-    if (canApplyToValue(patch, projected) && (resolvable.push(patch), projected))
-      try {
-        projected = applyAll(projected, [patch]);
-      } catch {
-      }
-  return resolvable;
+	let projected = value, resolvable = [];
+	for (let patch of patches) if (canApplyToValue(patch, projected) && (resolvable.push(patch), projected)) try {
+		projected = applyAll(projected, [patch]);
+	} catch {}
+	return resolvable;
 }
+/**
+* Scopes document-rooted Sanity patches to the given field path, returning
+* field-relative Portable Text Editor patches. Patches outside the field are
+* dropped. Returns `null` when the field (or an ancestor of it) is replaced
+* wholesale, in which case the caller should fall back to a full value sync.
+* Throws when a path expression cannot be converted.
+*
+* @internal
+*/
 function scopeRemotePatches(patches, fieldPath) {
-  const prefix = arrayifyPath(fieldPath), converted = convertPatches(patches), scoped = [];
-  for (const patch of converted) {
-    const overlap = Math.min(patch.path.length, prefix.length);
-    let touchesField = !0;
-    for (let index = 0; index < overlap; index++)
-      if (!segmentsEqual(patch.path[index], prefix[index])) {
-        touchesField = !1;
-        break;
-      }
-    if (touchesField) {
-      if (patch.path.length <= prefix.length)
-        return null;
-      scoped.push({
-        ...patch,
-        path: patch.path.slice(prefix.length)
-      });
-    }
-  }
-  return scoped;
+	let prefix = arrayifyPath(fieldPath), converted = convertPatches(patches), scoped = [];
+	for (let patch of converted) {
+		let overlap = Math.min(patch.path.length, prefix.length), touchesField = !0;
+		for (let index = 0; index < overlap; index++) if (!segmentsEqual(patch.path[index], prefix[index])) {
+			touchesField = !1;
+			break;
+		}
+		if (touchesField) {
+			if (patch.path.length <= prefix.length) return null;
+			scoped.push({
+				...patch,
+				path: patch.path.slice(prefix.length)
+			});
+		}
+	}
+	return scoped;
 }
 function debugTextOf(value) {
-  return Array.isArray(value) ? value.map((block) => Array.isArray(block.children) ? (block.children ?? []).map((child) => child.text ?? "").join("") : "").join(`
-`) : "";
+	return Array.isArray(value) ? value.map((block) => Array.isArray(block.children) ? (block.children ?? []).map((child) => child.text ?? "").join("") : "").join("\n") : "";
 }
-const REPAIR_CONFIRM_DELAY = (
-  // @ts-expect-error - dot notation required for Vite to replace at build time
-  process.env.NODE_ENV === "test" ? 150 : 1e3
-), pendingRepairs = /* @__PURE__ */ new WeakMap(), unflushedEdits = /* @__PURE__ */ new WeakMap();
+/**
+* How long an editor-versus-store divergence must persist, unchanged,
+* before the whole-value repair acts on it. When a remote transaction
+* arrives interleaved with the listener echoes of this client's own recent
+* edits, the store value is transiently wrong until the echo returns and
+* the rebase corrects it. A repair fired inside that window copies the
+* garbage into the editor and a follow-up repair restores the text at a
+* drifted offset, scrambling words the user typed in the meantime. The
+* window therefore has to outlast a slow listener echo round trip; real
+* divergence is stable and loses nothing by being repaired a beat later.
+*
+* Tests use a short window: their mock stores are synchronous, so echo
+* transients cannot occur, and waiting the production interval would only
+* slow every repair assertion down.
+*/
+const REPAIR_CONFIRM_DELAY = process.env.NODE_ENV === "test" ? 150 : 1e3, pendingRepairs = /* @__PURE__ */ new WeakMap(), unflushedEdits = /* @__PURE__ */ new WeakMap();
 function computeRepair(editor, remoteValue) {
-  const snapshot = editor.getSnapshot().context.value, stateSignature = JSON.stringify([snapshot, remoteValue]);
-  try {
-    return {
-      patches: toEngineSafePatches(convertPatches(diffValue(snapshot, remoteValue)), remoteValue),
-      convertible: !0,
-      signature: stateSignature
-    };
-  } catch {
-    return {
-      patches: [],
-      convertible: !1,
-      signature: `!${stateSignature}`
-    };
-  }
+	let snapshot = editor.getSnapshot().context.value, stateSignature = JSON.stringify([snapshot, remoteValue]);
+	try {
+		return {
+			patches: toEngineSafePatches(convertPatches(diffValue(snapshot, remoteValue)), remoteValue),
+			convertible: !0,
+			signature: stateSignature
+		};
+	} catch {
+		return {
+			patches: [],
+			convertible: !1,
+			signature: `!${stateSignature}`
+		};
+	}
 }
 function cancelPendingRepair(editor) {
-  const pending = pendingRepairs.get(editor);
-  pending && (clearTimeout(pending.timer), pendingRepairs.delete(editor));
+	let pending = pendingRepairs.get(editor);
+	pending && (clearTimeout(pending.timer), pendingRepairs.delete(editor));
 }
-function applySync({
-  editor,
-  getRemoteValue
-}) {
-  const remoteValue = getRemoteValue();
-  if (!remoteValue)
-    return;
-  const first = computeRepair(editor, remoteValue);
-  if (first.convertible && first.patches.length === 0) {
-    cancelPendingRepair(editor);
-    return;
-  }
-  debug.repair.enabled && debug.repair("editor and store texts diverged %o", {
-    editorText: debugTextOf(editor.getSnapshot().context.value),
-    remoteText: debugTextOf(remoteValue)
-  });
-  const pending = pendingRepairs.get(editor);
-  if (pending && pending.signature === first.signature)
-    return;
-  cancelPendingRepair(editor);
-  const timer = setTimeout(() => {
-    if (pendingRepairs.delete(editor), unflushedEdits.get(editor)) {
-      applySync({
-        editor,
-        getRemoteValue
-      });
-      return;
-    }
-    const latestRemote = getRemoteValue();
-    if (!latestRemote)
-      return;
-    const second = computeRepair(editor, latestRemote);
-    if (second.convertible && second.patches.length === 0)
-      return;
-    if (second.signature !== first.signature) {
-      applySync({
-        editor,
-        getRemoteValue
-      });
-      return;
-    }
-    if (!second.convertible) {
-      debug.repair("escalating to whole-value sync (unconvertible diff)"), editor.send({
-        type: "update value",
-        value: latestRemote
-      });
-      return;
-    }
-    const snapshot = editor.getSnapshot().context.value;
-    debug.repair("applying confirmed repair patches %o", second.patches), editor.send({
-      type: "patches",
-      patches: second.patches,
-      snapshot
-    });
-    const valueAfterPatches = editor.getSnapshot().context.value;
-    diffValue(valueAfterPatches, latestRemote).length > 0 && (debug.repair.enabled && debug.repair("escalating to whole-value sync %o", {
-      editorText: debugTextOf(valueAfterPatches),
-      remoteText: debugTextOf(latestRemote)
-    }), editor.send({
-      type: "update value",
-      value: latestRemote
-    }));
-  }, REPAIR_CONFIRM_DELAY);
-  pendingRepairs.set(editor, {
-    signature: first.signature,
-    timer
-  });
+function applySync({ editor, getRemoteValue }) {
+	let remoteValue = getRemoteValue();
+	if (!remoteValue) return;
+	let first = computeRepair(editor, remoteValue);
+	if (first.convertible && first.patches.length === 0) {
+		cancelPendingRepair(editor);
+		return;
+	}
+	debug.repair.enabled && debug.repair("editor and store texts diverged %o", {
+		editorText: debugTextOf(editor.getSnapshot().context.value),
+		remoteText: debugTextOf(remoteValue)
+	});
+	let pending = pendingRepairs.get(editor);
+	if (pending && pending.signature === first.signature) return;
+	cancelPendingRepair(editor);
+	let timer = setTimeout(() => {
+		if (pendingRepairs.delete(editor), unflushedEdits.get(editor)) {
+			applySync({
+				editor,
+				getRemoteValue
+			});
+			return;
+		}
+		let latestRemote = getRemoteValue();
+		if (!latestRemote) return;
+		let second = computeRepair(editor, latestRemote);
+		if (second.convertible && second.patches.length === 0) return;
+		if (second.signature !== first.signature) {
+			applySync({
+				editor,
+				getRemoteValue
+			});
+			return;
+		}
+		if (!second.convertible) {
+			debug.repair("escalating to whole-value sync (unconvertible diff)"), editor.send({
+				type: "update value",
+				value: latestRemote
+			});
+			return;
+		}
+		let snapshot = editor.getSnapshot().context.value;
+		debug.repair("applying confirmed repair patches %o", second.patches), editor.send({
+			type: "patches",
+			patches: second.patches,
+			snapshot
+		});
+		let valueAfterPatches = editor.getSnapshot().context.value;
+		diffValue(valueAfterPatches, latestRemote).length > 0 && (debug.repair.enabled && debug.repair("escalating to whole-value sync %o", {
+			editorText: debugTextOf(valueAfterPatches),
+			remoteText: debugTextOf(latestRemote)
+		}), editor.send({
+			type: "update value",
+			value: latestRemote
+		}));
+	}, REPAIR_CONFIRM_DELAY);
+	pendingRepairs.set(editor, {
+		signature: first.signature,
+		timer
+	});
 }
-const listenToEditor = fromCallback(({
-  sendBack,
-  input
-}) => {
-  const patchSubscription = input.editor.on("patch", () => {
-    unflushedEdits.set(input.editor, !0), sendBack({
-      type: "patch emitted"
-    });
-  }), mutationSubscription = input.editor.on("mutation", (event) => {
-    unflushedEdits.set(input.editor, !1), debug.mutation.enabled && debug.mutation("flushed %o", {
-      flushText: debugTextOf(event.value),
-      snapshotText: debugTextOf(input.editor.getSnapshot().context.value)
-    }), sendBack({
-      type: "mutation flushed",
-      value: event.value,
-      patches: event.patches
-    });
-  });
-  return () => {
-    patchSubscription.unsubscribe(), mutationSubscription.unsubscribe();
-  };
-}), listenToRemote = fromCallback(({
-  sendBack,
-  input
-}) => input.onRemoteValueChange(() => {
-  sendBack({
-    type: "remote value changed"
-  });
-})), listenToRemotePatches = fromCallback(({
-  sendBack,
-  input
-}) => input.onRemotePatches?.((patches) => {
-  sendBack({
-    type: "remote patches received",
-    patches
-  });
-})), QUIESCENT_REPAIR_DELAY = 500, valueSyncMachine = setup({
-  types: {
-    context: {},
-    input: {},
-    events: {}
-  },
-  actions: {
-    "send initial value": ({
-      context
-    }) => {
-      context.editor.send({
-        type: "update value",
-        value: context.getRemoteValue() ?? []
-      });
-    },
-    "push to remote": () => {
-      throw new Error("push to remote must be provided via .provide()");
-    },
-    "apply sync": ({
-      context
-    }) => {
-      applySync({
-        editor: context.editor,
-        getRemoteValue: context.getRemoteValue
-      });
-    },
-    "apply remote patches": ({
-      context,
-      event
-    }) => {
-      event.type === "remote patches received" && (debug.remote("applying remote patches %o", event.patches), queueMicrotask(() => {
-        const snapshot = context.editor.getSnapshot().context.value, remoteValue = context.getRemoteValue(), coalesced = remoteValue ? toEngineSafePatches(event.patches, remoteValue) : event.patches, patches = filterResolvablePatches(remoteValue ? filterInsertsMissingFromRemoteValue(coalesced, remoteValue) : coalesced, snapshot);
-        patches.length !== 0 && context.editor.send({
-          type: "patches",
-          patches,
-          snapshot
-        });
-      }));
-    }
-  },
-  actors: {
-    "listen to editor": listenToEditor,
-    "listen to remote": listenToRemote,
-    "listen to remote patches": listenToRemotePatches
-  }
+const listenToEditor = fromCallback(({ sendBack, input }) => {
+	let patchSubscription = input.editor.on("patch", () => {
+		unflushedEdits.set(input.editor, !0), sendBack({ type: "patch emitted" });
+	}), mutationSubscription = input.editor.on("mutation", (event) => {
+		unflushedEdits.set(input.editor, !1), debug.mutation.enabled && debug.mutation("flushed %o", {
+			flushText: debugTextOf(event.value),
+			snapshotText: debugTextOf(input.editor.getSnapshot().context.value)
+		}), sendBack({
+			type: "mutation flushed",
+			value: event.value,
+			patches: event.patches
+		});
+	});
+	return () => {
+		patchSubscription.unsubscribe(), mutationSubscription.unsubscribe();
+	};
+}), listenToRemote = fromCallback(({ sendBack, input }) => input.onRemoteValueChange(() => {
+	sendBack({ type: "remote value changed" });
+})), listenToRemotePatches = fromCallback(({ sendBack, input }) => input.onRemotePatches?.((patches) => {
+	sendBack({
+		type: "remote patches received",
+		patches
+	});
+})), valueSyncMachine = setup({
+	types: {
+		context: {},
+		input: {},
+		events: {}
+	},
+	actions: {
+		"send initial value": ({ context }) => {
+			context.editor.send({
+				type: "update value",
+				value: context.getRemoteValue() ?? []
+			});
+		},
+		"push to remote": () => {
+			throw Error("push to remote must be provided via .provide()");
+		},
+		"apply sync": ({ context }) => {
+			applySync({
+				editor: context.editor,
+				getRemoteValue: context.getRemoteValue
+			});
+		},
+		"apply remote patches": ({ context, event }) => {
+			event.type === "remote patches received" && (debug.remote("applying remote patches %o", event.patches), queueMicrotask(() => {
+				let snapshot = context.editor.getSnapshot().context.value, remoteValue = context.getRemoteValue(), coalesced = remoteValue ? toEngineSafePatches(event.patches, remoteValue) : event.patches, patches = filterResolvablePatches(remoteValue ? filterInsertsMissingFromRemoteValue(coalesced, remoteValue) : coalesced, snapshot);
+				patches.length !== 0 && context.editor.send({
+					type: "patches",
+					patches,
+					snapshot
+				});
+			}));
+		}
+	},
+	actors: {
+		"listen to editor": listenToEditor,
+		"listen to remote": listenToRemote,
+		"listen to remote patches": listenToRemotePatches
+	}
 }).createMachine({
-  id: "value sync",
-  context: ({
-    input
-  }) => ({
-    editor: input.editor,
-    getRemoteValue: input.getRemoteValue,
-    onRemoteValueChange: input.onRemoteValueChange,
-    onRemotePatches: input.onRemotePatches
-  }),
-  entry: ["send initial value"],
-  invoke: [{
-    src: "listen to editor",
-    input: ({
-      context
-    }) => ({
-      editor: context.editor
-    })
-  }, {
-    src: "listen to remote",
-    input: ({
-      context
-    }) => ({
-      onRemoteValueChange: context.onRemoteValueChange
-    })
-  }, {
-    src: "listen to remote patches",
-    input: ({
-      context
-    }) => ({
-      onRemotePatches: context.onRemotePatches
-    })
-  }],
-  // Two invariants, learned the hard way:
-  //
-  // 1. EVERY 'mutation flushed' event must be pushed, in every state. The
-  //    editor emits mutation events in bursts (one per input batch, e.g.
-  //    each backspace of a quick delete), and any state without a handler
-  //    silently drops the flush. A dropped flush permanently diverges the
-  //    store from the editor, and the whole-value repair then "heals" the
-  //    editor backwards, resurrecting deleted text.
-  // 2. The whole-value repair must only run when no local edits can be in
-  //    flight (quiescent 'idle'). Running it mid-typing diffs the editor
-  //    against a store that lags the user's keystrokes and stomps them.
-  //
-  // Operational patches from other clients still apply immediately in
-  // every state; the editor merges them with in-flight local changes.
-  initial: "idle",
-  states: {
-    idle: {
-      // One-shot repair after a quiet period. Covers divergence left by
-      // best-effort patch application while local edits were in flight
-      // (those states never repair; see below) when no further store
-      // event arrives to trigger the on-change repair.
-      after: {
-        [QUIESCENT_REPAIR_DELAY]: {
-          actions: ["apply sync"]
-        }
-      },
-      on: {
-        "patch emitted": {
-          target: "local write"
-        },
-        // Mutation events arrive in bursts (one per input batch), so a
-        // flush can land after a sibling flush already advanced the state.
-        "mutation flushed": {
-          target: "pushing to remote",
-          actions: ["push to remote"]
-        },
-        "remote value changed": {
-          actions: ["apply sync"]
-        },
-        // No immediate repair here: every remote patch batch also updates
-        // the store value, so the accompanying 'remote value changed'
-        // event runs the whole-value repair right after.
-        "remote patches received": {
-          actions: ["apply remote patches"]
-        }
-      }
-    },
-    "local write": {
-      on: {
-        "patch emitted": {},
-        "mutation flushed": {
-          target: "pushing to remote",
-          actions: ["push to remote"]
-        },
-        "remote value changed": {
-          target: "pending sync"
-        },
-        "remote patches received": {
-          target: "pending sync",
-          actions: ["apply remote patches"]
-        }
-      }
-    },
-    "pushing to remote": {
-      on: {
-        "patch emitted": {
-          target: "local write"
-        },
-        "mutation flushed": {
-          actions: ["push to remote"]
-        },
-        // No repair on the push acknowledgment: the editor snapshot can
-        // lag the live document while the user keeps typing, so a diff
-        // against the store here resurrects deleted text and duplicates
-        // in-flight keystrokes. Once truly idle, the store change or the
-        // quiescent delay runs the repair with a caught-up snapshot.
-        "remote value changed": {
-          target: "idle"
-        },
-        "remote patches received": {
-          actions: ["apply remote patches"]
-        }
-      }
-    },
-    "pending sync": {
-      on: {
-        "patch emitted": {},
-        "mutation flushed": {
-          target: "pushing to remote",
-          actions: ["push to remote"]
-        },
-        "remote value changed": {},
-        "remote patches received": {
-          actions: ["apply remote patches"]
-        }
-      }
-    }
-  }
+	id: "value sync",
+	context: ({ input }) => ({
+		editor: input.editor,
+		getRemoteValue: input.getRemoteValue,
+		onRemoteValueChange: input.onRemoteValueChange,
+		onRemotePatches: input.onRemotePatches
+	}),
+	entry: ["send initial value"],
+	invoke: [
+		{
+			src: "listen to editor",
+			input: ({ context }) => ({ editor: context.editor })
+		},
+		{
+			src: "listen to remote",
+			input: ({ context }) => ({ onRemoteValueChange: context.onRemoteValueChange })
+		},
+		{
+			src: "listen to remote patches",
+			input: ({ context }) => ({ onRemotePatches: context.onRemotePatches })
+		}
+	],
+	initial: "idle",
+	states: {
+		idle: {
+			after: { 500: { actions: ["apply sync"] } },
+			on: {
+				"patch emitted": { target: "local write" },
+				"mutation flushed": {
+					target: "pushing to remote",
+					actions: ["push to remote"]
+				},
+				"remote value changed": { actions: ["apply sync"] },
+				"remote patches received": { actions: ["apply remote patches"] }
+			}
+		},
+		"local write": { on: {
+			"patch emitted": {},
+			"mutation flushed": {
+				target: "pushing to remote",
+				actions: ["push to remote"]
+			},
+			"remote value changed": { target: "pending sync" },
+			"remote patches received": {
+				target: "pending sync",
+				actions: ["apply remote patches"]
+			}
+		} },
+		"pushing to remote": { on: {
+			"patch emitted": { target: "local write" },
+			"mutation flushed": { actions: ["push to remote"] },
+			"remote value changed": { target: "idle" },
+			"remote patches received": { actions: ["apply remote patches"] }
+		} },
+		"pending sync": { on: {
+			"patch emitted": {},
+			"mutation flushed": {
+				target: "pushing to remote",
+				actions: ["push to remote"]
+			},
+			"remote value changed": {},
+			"remote patches received": { actions: ["apply remote patches"] }
+		} }
+	}
 });
 function isRemotePatchesEvent(event) {
-  return event.type === "remote-patches";
+	return event.type === "remote-patches";
 }
 function getPublishedDocumentId(id) {
-  return id.startsWith("drafts.") ? id.slice(7) : id.startsWith("versions.") ? id.split(".").slice(2).join(".") : id;
+	return id.startsWith("drafts.") ? id.slice(7) : id.startsWith("versions.") ? id.split(".").slice(2).join(".") : id;
 }
+/**
+* @public
+*/
 function SDKValuePlugin(props) {
-  const $ = c(20), {
-    documentId,
-    documentType,
-    path
-  } = props, setSdkValue = useEditDocument(props), instance = useSanityInstance(props), applyActions = useApplyDocumentActions();
-  let t0;
-  $[0] !== documentId || $[1] !== documentType || $[2] !== instance || $[3] !== path ? (t0 = getDocumentState(instance, {
-    documentId,
-    documentType,
-    path
-  }), $[0] = documentId, $[1] = documentType, $[2] = instance, $[3] = path, $[4] = t0) : t0 = $[4];
-  const {
-    getCurrent,
-    subscribe
-  } = t0;
-  let t1;
-  $[5] !== documentId || $[6] !== instance || $[7] !== path ? (t1 = (callback) => subscribeDocumentEvents(instance, {
-    eventHandler: (event) => {
-      const candidate = event;
-      if (!isRemotePatchesEvent(candidate) || candidate.origin !== "remote" || getPublishedDocumentId(candidate.documentId) !== getPublishedDocumentId(documentId))
-        return;
-      let patches;
-      try {
-        patches = scopeRemotePatches(candidate.patches, path);
-      } catch {
-        return;
-      }
-      patches && patches.length > 0 && callback(patches);
-    }
-  }), $[5] = documentId, $[6] = instance, $[7] = path, $[8] = t1) : t1 = $[8];
-  const onRemotePatches = t1;
-  let t2;
-  $[9] !== applyActions || $[10] !== documentId || $[11] !== documentType || $[12] !== path ? (t2 = (patches_0) => {
-    const sanityPatches = convertPatchesToSanity(patches_0, {
-      prefix: path
-    }), action = {
-      ...editDocument({
-        documentId,
-        documentType
-      }, sanityPatches),
-      preserveOperations: !0
-    };
-    applyActions(action);
-  }, $[9] = applyActions, $[10] = documentId, $[11] = documentType, $[12] = path, $[13] = t2) : t2 = $[13];
-  const pushPatches = t2;
-  let t3;
-  return $[14] !== getCurrent || $[15] !== onRemotePatches || $[16] !== pushPatches || $[17] !== setSdkValue || $[18] !== subscribe ? (t3 = /* @__PURE__ */ jsx(ValueSyncPlugin, { getRemoteValue: getCurrent, pushValue: setSdkValue, onRemoteValueChange: subscribe, onRemotePatches, pushPatches }), $[14] = getCurrent, $[15] = onRemotePatches, $[16] = pushPatches, $[17] = setSdkValue, $[18] = subscribe, $[19] = t3) : t3 = $[19], t3;
+	let $ = c(20), { documentId, documentType, path } = props, setSdkValue = useEditDocument(props), instance = useSanityInstance(props), applyActions = useApplyDocumentActions(), t0;
+	$[0] !== documentId || $[1] !== documentType || $[2] !== instance || $[3] !== path ? (t0 = getDocumentState(instance, {
+		documentId,
+		documentType,
+		path
+	}), $[0] = documentId, $[1] = documentType, $[2] = instance, $[3] = path, $[4] = t0) : t0 = $[4];
+	let { getCurrent, subscribe } = t0, t1;
+	$[5] !== documentId || $[6] !== instance || $[7] !== path ? (t1 = (callback) => subscribeDocumentEvents(instance, { eventHandler: (event) => {
+		let candidate = event;
+		if (!isRemotePatchesEvent(candidate) || candidate.origin !== "remote" || getPublishedDocumentId(candidate.documentId) !== getPublishedDocumentId(documentId)) return;
+		let patches;
+		try {
+			patches = scopeRemotePatches(candidate.patches, path);
+		} catch {
+			return;
+		}
+		patches && patches.length > 0 && callback(patches);
+	} }), $[5] = documentId, $[6] = instance, $[7] = path, $[8] = t1) : t1 = $[8];
+	let onRemotePatches = t1, t2;
+	$[9] !== applyActions || $[10] !== documentId || $[11] !== documentType || $[12] !== path ? (t2 = (patches_0) => {
+		let sanityPatches = convertPatchesToSanity(patches_0, { prefix: path }), action = {
+			...editDocument({
+				documentId,
+				documentType
+			}, sanityPatches),
+			preserveOperations: !0
+		};
+		applyActions(action);
+	}, $[9] = applyActions, $[10] = documentId, $[11] = documentType, $[12] = path, $[13] = t2) : t2 = $[13];
+	let pushPatches = t2, t3;
+	return $[14] !== getCurrent || $[15] !== onRemotePatches || $[16] !== pushPatches || $[17] !== setSdkValue || $[18] !== subscribe ? (t3 = /* @__PURE__ */ jsx(ValueSyncPlugin, {
+		getRemoteValue: getCurrent,
+		pushValue: setSdkValue,
+		onRemoteValueChange: subscribe,
+		onRemotePatches,
+		pushPatches
+	}), $[14] = getCurrent, $[15] = onRemotePatches, $[16] = pushPatches, $[17] = setSdkValue, $[18] = subscribe, $[19] = t3) : t3 = $[19], t3;
 }
+/**
+* NOTE: You are probably looking for SDKValuePlugin instead of this.
+* This is a lower-level plugin that only handles syncing the value
+* between the editor and a remote source. It does not know anything
+* about Sanity documents or how to fetch/update them.
+*
+* May be removed in the future, do not rely on this directly.
+*
+* @internal
+*/
 function ValueSyncPlugin(props) {
-  const $ = c(8), {
-    getRemoteValue,
-    pushValue,
-    onRemoteValueChange,
-    onRemotePatches,
-    pushPatches
-  } = props, editor = useEditor();
-  let t0;
-  $[0] !== pushPatches || $[1] !== pushValue ? (t0 = valueSyncMachine.provide({
-    actions: {
-      "push to remote": (t12) => {
-        const {
-          context,
-          event
-        } = t12;
-        if (event.type === "mutation flushed") {
-          if (pushPatches && event.patches.length > 0)
-            try {
-              const mergeable = toMergeableMarkDefsPatches(event.patches, context.getRemoteValue);
-              debug.push("pushing patches %o", mergeable), pushPatches(mergeable);
-              return;
-            } catch {
-            }
-          debug.push.enabled && debug.push("pushing whole value %s", debugTextOf(event.value ?? context.editor.getSnapshot().context.value)), pushValue(event.value ?? context.editor.getSnapshot().context.value);
-        }
-      }
-    }
-  }), $[0] = pushPatches, $[1] = pushValue, $[2] = t0) : t0 = $[2];
-  let t1;
-  return $[3] !== editor || $[4] !== getRemoteValue || $[5] !== onRemotePatches || $[6] !== onRemoteValueChange ? (t1 = {
-    input: {
-      editor,
-      getRemoteValue,
-      onRemoteValueChange,
-      onRemotePatches
-    }
-  }, $[3] = editor, $[4] = getRemoteValue, $[5] = onRemotePatches, $[6] = onRemoteValueChange, $[7] = t1) : t1 = $[7], useActorRef(t0, t1), null;
+	let $ = c(8), { getRemoteValue, pushValue, onRemoteValueChange, onRemotePatches, pushPatches } = props, editor = useEditor(), t0;
+	$[0] !== pushPatches || $[1] !== pushValue ? (t0 = valueSyncMachine.provide({ actions: { "push to remote": (t1) => {
+		let { context, event } = t1;
+		if (event.type === "mutation flushed") {
+			if (pushPatches && event.patches.length > 0) try {
+				let mergeable = toMergeableMarkDefsPatches(event.patches, context.getRemoteValue);
+				debug.push("pushing patches %o", mergeable), pushPatches(mergeable);
+				return;
+			} catch {}
+			debug.push.enabled && debug.push("pushing whole value %s", debugTextOf(event.value ?? context.editor.getSnapshot().context.value)), pushValue(event.value ?? context.editor.getSnapshot().context.value);
+		}
+	} } }), $[0] = pushPatches, $[1] = pushValue, $[2] = t0) : t0 = $[2];
+	let t1;
+	return $[3] !== editor || $[4] !== getRemoteValue || $[5] !== onRemotePatches || $[6] !== onRemoteValueChange ? (t1 = { input: {
+		editor,
+		getRemoteValue,
+		onRemoteValueChange,
+		onRemotePatches
+	} }, $[3] = editor, $[4] = getRemoteValue, $[5] = onRemotePatches, $[6] = onRemoteValueChange, $[7] = t1) : t1 = $[7], useActorRef(t0, t1), null;
 }
+/**
+* Reports the local user's caret in a Portable Text field, so other people in
+* the same document can see where they are.
+*
+* Place it inside `EditorProvider`. Prefer `SDKPortableTextEditable`, which
+* reports and draws in one component; reach for this when you render
+* `PortableTextEditable` yourself.
+*
+* Which document is reported follows the handle's perspective, or the ambient
+* one from `ResourceProvider`. Pass the plain document id and let the
+* perspective select the draft, the published document, or a release version.
+*
+* @public
+*/
 function SDKPresencePlugin(props) {
-  const $ = c(7);
-  let handle, path;
-  $[0] !== props ? ({
-    path,
-    ...handle
-  } = props, $[0] = props, $[1] = handle, $[2] = path) : (handle = $[1], path = $[2]);
-  const selection = useLocalSelection(), fieldPath = useFieldPath(path);
-  let t0;
-  return $[3] !== fieldPath || $[4] !== handle || $[5] !== selection ? (t0 = {
-    ...handle,
-    path: fieldPath,
-    selection
-  }, $[3] = fieldPath, $[4] = handle, $[5] = selection, $[6] = t0) : t0 = $[6], useReportPresence(t0), null;
+	let $ = c(7), handle, path;
+	$[0] === props ? (handle = $[1], path = $[2]) : ({path, ...handle} = props, $[0] = props, $[1] = handle, $[2] = path);
+	let selection = useLocalSelection(), fieldPath = useFieldPath(path), t0;
+	return $[3] !== fieldPath || $[4] !== handle || $[5] !== selection ? (t0 = {
+		...handle,
+		path: fieldPath,
+		selection
+	}, $[3] = fieldPath, $[4] = handle, $[5] = selection, $[6] = t0) : t0 = $[6], useReportPresence(t0), null;
 }
+/**
+* Other people's carets in a Portable Text field, as range decorations.
+*
+* Pass the result to `<PortableTextEditable rangeDecorations={...} />`, or use
+* `SDKPortableTextEditable` and skip the wiring. Each caret stays anchored as
+* the local user types, and disappears when the participant leaves or their
+* session expires.
+*
+* The local user is never included, so an app does not draw its own caret.
+* Participants are counted by session, so the same person in two tabs draws two
+* carets.
+*
+* @public
+*/
 function useSDKPresenceCursors(options) {
-  const $ = c(12);
-  let handle, path, renderCursor;
-  $[0] !== options ? ({
-    path,
-    renderCursor,
-    ...handle
-  } = options, $[0] = options, $[1] = handle, $[2] = path, $[3] = renderCursor) : (handle = $[1], path = $[2], renderCursor = $[3]);
-  const fieldPath = useFieldPath(path);
-  let t0;
-  $[4] !== fieldPath || $[5] !== handle ? (t0 = {
-    ...handle,
-    path: fieldPath,
-    excludeVersions: !0
-  }, $[4] = fieldPath, $[5] = handle, $[6] = t0) : t0 = $[6];
-  const {
-    presence
-  } = usePresenceForDocument(t0);
-  let t1;
-  $[7] !== presence ? (t1 = presence.flatMap(_temp), $[7] = presence, $[8] = t1) : t1 = $[8];
-  const cursors = t1;
-  let t2;
-  return $[9] !== cursors || $[10] !== renderCursor ? (t2 = {
-    cursors,
-    renderCursor
-  }, $[9] = cursors, $[10] = renderCursor, $[11] = t2) : t2 = $[11], useRemoteCursors(t2);
+	let $ = c(12), handle, path, renderCursor;
+	$[0] === options ? (handle = $[1], path = $[2], renderCursor = $[3]) : ({path, renderCursor, ...handle} = options, $[0] = options, $[1] = handle, $[2] = path, $[3] = renderCursor);
+	let fieldPath = useFieldPath(path), t0;
+	$[4] !== fieldPath || $[5] !== handle ? (t0 = {
+		...handle,
+		path: fieldPath,
+		excludeVersions: !0
+	}, $[4] = fieldPath, $[5] = handle, $[6] = t0) : t0 = $[6];
+	let { presence } = usePresenceForDocument(t0), t1;
+	$[7] === presence ? t1 = $[8] : (t1 = presence.flatMap(_temp), $[7] = presence, $[8] = t1);
+	let cursors = t1, t2;
+	return $[9] !== cursors || $[10] !== renderCursor ? (t2 = {
+		cursors,
+		renderCursor
+	}, $[9] = cursors, $[10] = renderCursor, $[11] = t2) : t2 = $[11], useRemoteCursors(t2);
 }
+/**
+* The SDK's presence hooks address fields by path array, because a field-level
+* path inside Portable Text needs keyed segments. This package takes the same
+* string expression as `SDKValuePlugin` everywhere and converts here.
+*/
 function _temp(participant) {
-  return participant.selection ? [{
-    sessionId: participant.sessionId,
-    selection: participant.selection,
-    user: participant.user
-  }] : [];
+	return participant.selection ? [{
+		sessionId: participant.sessionId,
+		selection: participant.selection,
+		user: participant.user
+	}] : [];
 }
 function useFieldPath(path) {
-  const $ = c(2);
-  let t0;
-  return $[0] !== path ? (t0 = arrayifyPath(path), $[0] = path, $[1] = t0) : t0 = $[1], t0;
+	let $ = c(2), t0;
+	return $[0] === path ? t0 = $[1] : (t0 = arrayifyPath(path), $[0] = path, $[1] = t0), t0;
 }
-const CARET_COLORS = ["#e0508a", "#c05fd8", "#7c66e8", "#2f8fdd", "#1f9c8f", "#4f9c2f", "#c98a1c", "#d4603a"], DOT_SIZE = 6;
+/**
+* Mid-tone hues, so a caret stays legible whether the app is light or dark. This
+* package cannot read the app's theme, so it does not try.
+*/
+const CARET_COLORS = [
+	"#e0508a",
+	"#c05fd8",
+	"#7c66e8",
+	"#2f8fdd",
+	"#1f9c8f",
+	"#4f9c2f",
+	"#c98a1c",
+	"#d4603a"
+];
+/**
+* Picks a stable colour for a participant.
+*
+* Keyed on the user rather than the session, so one person in two tabs draws two
+* carets in the same colour. The Studio colours by user for the same reason.
+*
+* @public
+*/
 function getCaretColor(userId) {
-  let hash = 0;
-  for (let index = 0; index < userId.length; index++)
-    hash = (hash * 31 + userId.charCodeAt(index)) % 1000003;
-  return CARET_COLORS[hash % CARET_COLORS.length];
+	let hash = 0;
+	for (let index = 0; index < userId.length; index++) hash = (hash * 31 + userId.charCodeAt(index)) % 1000003;
+	return CARET_COLORS[hash % CARET_COLORS.length];
 }
-const renderDefaultCursor = (cursor) => (props) => /* @__PURE__ */ jsx(DefaultCaret, { cursor, children: props.children });
+/**
+* Draws a remote caret when no `renderCursor` was given: a coloured line with a
+* dot above it, and the participant's name on hover.
+*
+* Deliberately plain, and styled inline so it needs no stylesheet. Pass your own
+* `renderCursor` to match your design.
+*
+* @public
+*/
+const renderDefaultCursor = (cursor) => (props) => /* @__PURE__ */ jsx(DefaultCaret, {
+	cursor,
+	children: props.children
+});
 function DefaultCaret(props) {
-  const $ = c(17), {
-    cursor,
-    children
-  } = props;
-  let t0;
-  $[0] !== cursor.user.sanityUserId ? (t0 = getCaretColor(cursor.user.sanityUserId), $[0] = cursor.user.sanityUserId, $[1] = t0) : t0 = $[1];
-  const color = t0, displayName = cursor.user.profile.displayName, t1 = `presence-caret-${cursor.sessionId}`, t2 = `2px solid ${color}`;
-  let t3;
-  $[2] !== t2 ? (t3 = {
-    borderLeft: t2,
-    marginLeft: -1,
-    position: "relative",
-    pointerEvents: "none"
-  }, $[2] = t2, $[3] = t3) : t3 = $[3];
-  const t4 = `presence-caret-dot-${cursor.sessionId}`;
-  let t5;
-  $[4] !== color ? (t5 = {
-    backgroundColor: color,
-    borderRadius: "50%",
-    height: DOT_SIZE,
-    left: -1,
-    pointerEvents: "auto",
-    position: "absolute",
-    top: -5,
-    transform: "translateX(-50%)",
-    width: DOT_SIZE
-  }, $[4] = color, $[5] = t5) : t5 = $[5];
-  let t6;
-  $[6] !== displayName || $[7] !== t4 || $[8] !== t5 ? (t6 = /* @__PURE__ */ jsx("span", { "data-testid": t4, style: t5, title: displayName }), $[6] = displayName, $[7] = t4, $[8] = t5, $[9] = t6) : t6 = $[9];
-  let t7;
-  $[10] !== t1 || $[11] !== t3 || $[12] !== t6 ? (t7 = /* @__PURE__ */ jsx("span", { contentEditable: !1, "data-testid": t1, style: t3, children: t6 }), $[10] = t1, $[11] = t3, $[12] = t6, $[13] = t7) : t7 = $[13];
-  let t8;
-  return $[14] !== children || $[15] !== t7 ? (t8 = /* @__PURE__ */ jsxs(Fragment, { children: [
-    t7,
-    children
-  ] }), $[14] = children, $[15] = t7, $[16] = t8) : t8 = $[16], t8;
+	let $ = c(17), { cursor, children } = props, t0;
+	$[0] === cursor.user.sanityUserId ? t0 = $[1] : (t0 = getCaretColor(cursor.user.sanityUserId), $[0] = cursor.user.sanityUserId, $[1] = t0);
+	let color = t0, displayName = cursor.user.profile.displayName, t1 = `presence-caret-${cursor.sessionId}`, t2 = `2px solid ${color}`, t3;
+	$[2] === t2 ? t3 = $[3] : (t3 = {
+		borderLeft: t2,
+		marginLeft: -1,
+		position: "relative",
+		pointerEvents: "none"
+	}, $[2] = t2, $[3] = t3);
+	let t4 = `presence-caret-dot-${cursor.sessionId}`, t5;
+	$[4] === color ? t5 = $[5] : (t5 = {
+		backgroundColor: color,
+		borderRadius: "50%",
+		height: 6,
+		left: -1,
+		pointerEvents: "auto",
+		position: "absolute",
+		top: -5,
+		transform: "translateX(-50%)",
+		width: 6
+	}, $[4] = color, $[5] = t5);
+	let t6;
+	$[6] !== displayName || $[7] !== t4 || $[8] !== t5 ? (t6 = /* @__PURE__ */ jsx("span", {
+		"data-testid": t4,
+		style: t5,
+		title: displayName
+	}), $[6] = displayName, $[7] = t4, $[8] = t5, $[9] = t6) : t6 = $[9];
+	let t7;
+	$[10] !== t1 || $[11] !== t3 || $[12] !== t6 ? (t7 = /* @__PURE__ */ jsx("span", {
+		contentEditable: !1,
+		"data-testid": t1,
+		style: t3,
+		children: t6
+	}), $[10] = t1, $[11] = t3, $[12] = t6, $[13] = t7) : t7 = $[13];
+	let t8;
+	return $[14] !== children || $[15] !== t7 ? (t8 = /* @__PURE__ */ jsxs(Fragment, { children: [t7, children] }), $[14] = children, $[15] = t7, $[16] = t8) : t8 = $[16], t8;
 }
+/**
+* A `PortableTextEditable` wired to a Sanity document: the field's value syncs
+* both ways, the local user's caret is reported, and other people's carets are
+* drawn.
+*
+* Place it inside `EditorProvider` in place of `PortableTextEditable`. Every
+* other prop is forwarded untouched, and `rangeDecorations` you pass are kept
+* and merged with the presence carets rather than replaced.
+*
+* Nothing else is needed: this replaces a separate `SDKValuePlugin`.
+*
+* @example
+* ```tsx
+* <EditorProvider initialConfig={{schemaDefinition}}>
+*   <SDKPortableTextEditable
+*     {...documentHandle}
+*     path="content"
+*     renderCursor={({user}) => (props) => (
+*       <Caret user={user}>{props.children}</Caret>
+*     )}
+*   />
+* </EditorProvider>
+* ```
+*
+* @public
+*/
 function SDKPortableTextEditable(props) {
-  const $ = c(25);
-  let editableProps, handle, path, rangeDecorations, t0;
-  if ($[0] !== props) {
-    const {
-      handle: t12,
-      path: t22,
-      renderCursor,
-      rangeDecorations: t32,
-      editableProps: t42
-    } = splitEditableProps(props);
-    handle = t12, path = t22, rangeDecorations = t32, editableProps = t42, t0 = resolveCursorRenderer(renderCursor), $[0] = props, $[1] = editableProps, $[2] = handle, $[3] = path, $[4] = rangeDecorations, $[5] = t0;
-  } else
-    editableProps = $[1], handle = $[2], path = $[3], rangeDecorations = $[4], t0 = $[5];
-  const renderer = t0;
-  let t1;
-  $[6] !== handle || $[7] !== path || $[8] !== renderer.renderCursor ? (t1 = {
-    ...handle,
-    path,
-    renderCursor: renderer.renderCursor
-  }, $[6] = handle, $[7] = path, $[8] = renderer.renderCursor, $[9] = t1) : t1 = $[9];
-  const cursors = useSDKPresenceCursors(t1);
-  let t2;
-  $[10] !== cursors || $[11] !== rangeDecorations || $[12] !== renderer.drawCursors ? (t2 = mergePresenceDecorations(rangeDecorations, cursors, renderer.drawCursors), $[10] = cursors, $[11] = rangeDecorations, $[12] = renderer.drawCursors, $[13] = t2) : t2 = $[13];
-  const decorations = t2;
-  let t3;
-  $[14] !== decorations || $[15] !== editableProps ? (t3 = /* @__PURE__ */ jsx(PortableTextEditable, { ...editableProps, rangeDecorations: decorations }), $[14] = decorations, $[15] = editableProps, $[16] = t3) : t3 = $[16];
-  let t4, t5;
-  $[17] !== handle || $[18] !== path ? (t4 = /* @__PURE__ */ jsx(SDKValuePlugin, { ...handle, path }), t5 = /* @__PURE__ */ jsx(SDKPresencePlugin, { ...handle, path }), $[17] = handle, $[18] = path, $[19] = t4, $[20] = t5) : (t4 = $[19], t5 = $[20]);
-  let t6;
-  return $[21] !== t3 || $[22] !== t4 || $[23] !== t5 ? (t6 = /* @__PURE__ */ jsxs(Fragment, { children: [
-    t3,
-    t4,
-    t5
-  ] }), $[21] = t3, $[22] = t4, $[23] = t5, $[24] = t6) : t6 = $[24], t6;
+	let $ = c(25), editableProps, handle, path, rangeDecorations, t0;
+	if ($[0] !== props) {
+		let { handle: t1, path: t2, renderCursor, rangeDecorations: t3, editableProps: t4 } = splitEditableProps(props);
+		handle = t1, path = t2, rangeDecorations = t3, editableProps = t4, t0 = resolveCursorRenderer(renderCursor), $[0] = props, $[1] = editableProps, $[2] = handle, $[3] = path, $[4] = rangeDecorations, $[5] = t0;
+	} else editableProps = $[1], handle = $[2], path = $[3], rangeDecorations = $[4], t0 = $[5];
+	let renderer = t0, t1;
+	$[6] !== handle || $[7] !== path || $[8] !== renderer.renderCursor ? (t1 = {
+		...handle,
+		path,
+		renderCursor: renderer.renderCursor
+	}, $[6] = handle, $[7] = path, $[8] = renderer.renderCursor, $[9] = t1) : t1 = $[9];
+	let cursors = useSDKPresenceCursors(t1), t2;
+	$[10] !== cursors || $[11] !== rangeDecorations || $[12] !== renderer.drawCursors ? (t2 = mergePresenceDecorations(rangeDecorations, cursors, renderer.drawCursors), $[10] = cursors, $[11] = rangeDecorations, $[12] = renderer.drawCursors, $[13] = t2) : t2 = $[13];
+	let decorations = t2, t3;
+	$[14] !== decorations || $[15] !== editableProps ? (t3 = /* @__PURE__ */ jsx(PortableTextEditable, {
+		...editableProps,
+		rangeDecorations: decorations
+	}), $[14] = decorations, $[15] = editableProps, $[16] = t3) : t3 = $[16];
+	let t4, t5;
+	$[17] !== handle || $[18] !== path ? (t4 = /* @__PURE__ */ jsx(SDKValuePlugin, {
+		...handle,
+		path
+	}), t5 = /* @__PURE__ */ jsx(SDKPresencePlugin, {
+		...handle,
+		path
+	}), $[17] = handle, $[18] = path, $[19] = t4, $[20] = t5) : (t4 = $[19], t5 = $[20]);
+	let t6;
+	return $[21] !== t3 || $[22] !== t4 || $[23] !== t5 ? (t6 = /* @__PURE__ */ jsxs(Fragment, { children: [
+		t3,
+		t4,
+		t5
+	] }), $[21] = t3, $[22] = t4, $[23] = t5, $[24] = t6) : t6 = $[24], t6;
 }
+/**
+* Splits the props into the document handle, this component's own props, and
+* what is forwarded to `PortableTextEditable`. Keeping handle fields out of the
+* forwarded set is what stops them reaching the DOM as attributes.
+*
+* @internal
+*/
 function splitEditableProps(props) {
-  const {
-    documentId,
-    documentType,
-    projectId,
-    dataset,
-    resource,
-    resourceName,
-    source,
-    liveEdit,
-    perspective,
-    path,
-    renderCursor,
-    rangeDecorations,
-    ...editableProps
-  } = props;
-  return {
-    // Only the fields the caller actually passed. The SDK resolves an ambient
-    // perspective and resource from context with `Object.hasOwn`, so forwarding
-    // `perspective: undefined` would override what `ResourceProvider` set rather
-    // than defer to it, and the field would sync and report against the draft
-    // instead of the release the app is showing.
-    handle: {
-      documentId,
-      documentType,
-      ..."projectId" in props && {
-        projectId
-      },
-      ..."dataset" in props && {
-        dataset
-      },
-      ..."resource" in props && {
-        resource
-      },
-      ..."resourceName" in props && {
-        resourceName
-      },
-      ..."source" in props && {
-        source
-      },
-      ..."liveEdit" in props && {
-        liveEdit
-      },
-      ..."perspective" in props && {
-        perspective
-      }
-    },
-    path,
-    renderCursor,
-    rangeDecorations,
-    editableProps
-  };
+	let { documentId, documentType, projectId, dataset, resource, resourceName, source, liveEdit, perspective, path, renderCursor, rangeDecorations, ...editableProps } = props;
+	return {
+		handle: {
+			documentId,
+			documentType,
+			..."projectId" in props && { projectId },
+			..."dataset" in props && { dataset },
+			..."resource" in props && { resource },
+			..."resourceName" in props && { resourceName },
+			..."source" in props && { source },
+			..."liveEdit" in props && { liveEdit },
+			..."perspective" in props && { perspective }
+		},
+		path,
+		renderCursor,
+		rangeDecorations,
+		editableProps
+	};
 }
+/**
+* Decides which caret component to draw with, and whether to draw at all.
+*
+* Presence is subscribed to either way, because hooks cannot be called
+* conditionally, so switching carets off discards the decorations rather than
+* skipping the work.
+*
+* @internal
+*/
 function resolveCursorRenderer(renderCursor) {
-  return {
-    renderCursor: renderCursor ?? renderDefaultCursor,
-    drawCursors: renderCursor !== null
-  };
+	return {
+		renderCursor: renderCursor ?? renderDefaultCursor,
+		drawCursors: renderCursor !== null
+	};
 }
+/**
+* Appends the presence carets to whatever decorations the caller passed, so
+* theirs survive. The Studio merges the same way. When carets are switched off
+* the caller's own decorations pass straight through.
+*
+* @internal
+*/
 function mergePresenceDecorations(rangeDecorations, cursors, drawCursors) {
-  return drawCursors ? [...rangeDecorations ?? [], ...cursors] : rangeDecorations;
+	return drawCursors ? [...rangeDecorations ?? [], ...cursors] : rangeDecorations;
 }
-export {
-  SDKPortableTextEditable,
-  SDKPresencePlugin,
-  SDKValuePlugin,
-  ValueSyncPlugin,
-  useSDKPresenceCursors
-};
-//# sourceMappingURL=index.js.map
+/**
+* Splitting the props by hand is what keeps document handle fields off the DOM,
+* so every field has to be listed above. `sdk-editable.test.ts` fails to compile
+* if `DocumentHandle` gains one. Note that `@sanity/sdk-react` adds fields to the
+* core handle, so it has to be read from there.
+*/
+export { SDKPortableTextEditable, SDKPresencePlugin, SDKValuePlugin, ValueSyncPlugin, useSDKPresenceCursors };
+
+//# sourceMappingURL=index.js.map