@templatical/core 0.49.0 → 0.50.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Block, BlockDefaults, BlockLock, BlockLockHolder, BlockType, CollaborationActor, CollaborationConflictCode, CollaborationConnectionState, CollaborationMember, CollaborationProvider, CollaborationRemoteChange, Comment, CommentAuthor, CommentInput, CommentPatch, CommentsListParams, CommentsProvider, CustomBlock, CustomBlockDefinition, MediaProvider, Operation, SavedBlock, SavedBlockPatch, SavedBlocksListParams, SavedBlocksProvider, Template, TemplateContent, TemplateDefaults, TemplateSaveTrigger, TemplateSettings, TemplateVersion, TemplatesProvider, UiTheme, VersionHistoryListParams, VersionHistoryProvider, ViewportSize } from "@templatical/types";
+import { Block, BlockDefaults, BlockLock, BlockLockHolder, BlockType, CollaborationActor, CollaborationConflictCode, CollaborationConnectionState, CollaborationMember, CollaborationProvider, CollaborationRemoteChange, Comment, CommentAuthor, CommentInput, CommentPatch, CommentsListParams, CommentsProvider, CustomBlock, CustomBlockDefinition, MediaProvider, Operation, OperationError, SavedBlock, SavedBlockPatch, SavedBlocksListParams, SavedBlocksProvider, Template, TemplateContent, TemplateDefaults, TemplateSaveTrigger, TemplateSettings, TemplateVersion, TemplatesProvider, UiTheme, VersionHistoryListParams, VersionHistoryProvider, ViewportSize, invertOperations } from "@templatical/types";
 import { ComputedRef, DeepReadonly, Ref } from "@vue/reactivity";
 import { ComputedRef as ComputedRef$1, Ref as Ref$1 } from "vue";
 //#region src/editor.d.ts
@@ -21,7 +21,7 @@ interface EditorState {
   isDirty: boolean;
   /** True for the duration of a `save()` call. */
   isSaving: boolean;
-  /** True for the duration of a `create()` or `load()` call. */
+  /** True while the latest `create()` or `load()` request is pending. */
   isLoading: boolean;
   uiTheme: UiTheme;
 }
@@ -48,6 +48,8 @@ interface UseEditorOptions {
 }
 interface UseEditorReturn {
   state: DeepReadonly<EditorState>;
+  /** Increments when create/load commits, including a reload of the same id. */
+  loadVersion: Readonly<Ref<number>>;
   content: Ref<TemplateContent>;
   selectedBlock: Ref<Block | null>;
   setContent: (content: TemplateContent, markDirty?: boolean) => void;
@@ -91,8 +93,8 @@ interface UseEditorReturn {
     name?: string;
     content?: TemplateContent;
   }) => Promise<Template>;
-  /** Fetch a template and make it the editor's content. */
-  load: (templateId: string) => Promise<Template>;
+  /** Fetch a template; an optional guard can discard a stale response. */
+  load: (templateId: string, shouldApply?: () => boolean) => Promise<Template>;
   /**
    * Persist the loaded template's name + content as a patch.
    *
@@ -268,22 +270,6 @@ export declare function useHistoryInterceptor(editor: HistoryInterceptorEditor,
  */
 export declare function diffContent(before: TemplateContent, after: TemplateContent): Operation[];
 //#endregion
-//#region src/invert-operations.d.ts
-/**
- * The batch that undoes `ops`, given the content they apply to. Each operation
- * is inverted against the content just before it, and the inverses run in
- * reverse order.
- *
- * Every inverse that can be guarded is: it expects what its operation left
- * behind, so an undo that a later edit by someone else has overtaken is refused
- * (`precondition_failed`, `anchor_missing`, `block_missing`) instead of
- * overwriting that edit. A `setContent` inverse has no guard; the backend's
- * `locked_by_others` rule is what stops it while others are editing.
- *
- * Throws the engine's `OperationError` when `ops` don't apply to `before`.
- */
-export declare function invertOperations(before: TemplateContent, ops: readonly Operation[]): Operation[];
-//#endregion
 //#region src/collaboration.d.ts
 /** The template fields the controller reads, as the editor's readonly state holds them. */
 type CollaborationTemplate = DeepReadonly<Pick<Template, "id" | "revision" | "content">>;
@@ -325,6 +311,24 @@ interface CollaborationRemoteResync {
   revision: number;
   actor: CollaborationActor;
 }
+/** How {@link UseCollaborationReturn.applyOperations} sends a batch. */
+interface CollaborationApplyOptions {
+  /** Sent as the batch's `origin`: an AI turn produced it (BY9). */
+  origin: "ai";
+  /**
+   * The turn the batch belongs to. Batches of one turn share an undo step
+   * while that step is the newest one.
+   */
+  turn: string;
+}
+/** What {@link UseCollaborationReturn.applyOperations} answers. */
+type CollaborationApplyResult = {
+  applied: true;
+  inverse: Operation[];
+} | {
+  applied: false;
+  error: OperationError;
+};
 interface UseCollaborationOptions {
   provider: CollaborationProvider;
   /**
@@ -386,6 +390,13 @@ interface UseCollaborationReturn {
   catchUp: () => Promise<void>;
   /** Whether the block exists in the content the backend confirmed. */
   hasConfirmedBlock: (blockId: string) => boolean;
+  /**
+   * Apply a batch this editor was handed (an AI turn's) as this session's
+   * own: checked against the view with this session's locks, put on the
+   * canvas, sent with its `origin`, and undone with the rest of its turn. A
+   * refusal changes nothing and sends nothing.
+   */
+  applyOperations: (ops: Operation[], options: CollaborationApplyOptions) => CollaborationApplyResult;
   destroy: () => void;
 }
 /**
@@ -687,5 +698,5 @@ interface UseCommentListenerOptions {
  */
 export declare function useCommentListener(options: UseCommentListenerOptions): void;
 //#endregion
-export type { CollaborationEditor, CollaborationNotice, CollaborationRemoteResync, CollaborationTemplate, EditorState, LocalStorageMediaProviderOptions, LocalStorageSavedBlocksOptions, UseAutoSaveOptions, UseAutoSaveReturn, UseBlockActionsOptions, UseBlockActionsReturn, UseCollaborationOptions, UseCollaborationReturn, UseCommentListenerOptions, UseCommentsOptions, UseCommentsReturn, UseConditionPreviewReturn, UseEditorOptions, UseEditorReturn, UseHistoryOptions, UseHistoryReturn, UseSavedBlocksOptions, UseSavedBlocksReturn, UseVersionHistoryOptions, UseVersionHistoryReturn };
+export { type CollaborationApplyOptions, type CollaborationApplyResult, type CollaborationEditor, type CollaborationNotice, type CollaborationRemoteResync, type CollaborationTemplate, type EditorState, type LocalStorageMediaProviderOptions, type LocalStorageSavedBlocksOptions, type UseAutoSaveOptions, type UseAutoSaveReturn, type UseBlockActionsOptions, type UseBlockActionsReturn, type UseCollaborationOptions, type UseCollaborationReturn, type UseCommentListenerOptions, type UseCommentsOptions, type UseCommentsReturn, type UseConditionPreviewReturn, type UseEditorOptions, type UseEditorReturn, type UseHistoryOptions, type UseHistoryReturn, type UseSavedBlocksOptions, type UseSavedBlocksReturn, type UseVersionHistoryOptions, type UseVersionHistoryReturn, invertOperations };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,4 @@
-import { OperationError, SdkError, applyOperations, applyOperationsInPlace, assertNoSlotInContent, assertNoWrapperInContent, cloneBlock, createBlock, createDefaultTemplateContent, deepEqual, generateId, getColumnCount, safeClone } from "@templatical/types";
+import { OperationError, SdkError, applyOperations, applyOperationsInPlace, assertNoSlotInContent, assertNoWrapperInContent, cloneBlock, createBlock, createDefaultTemplateContent, deepEqual, generateId, getColumnCount, invertOperations, invertOperations as invertOperations$1, safeClone } from "@templatical/types";
 import { computed, getCurrentScope, onScopeDispose, reactive, readonly, ref, shallowRef, watch } from "@vue/reactivity";
 import { computed as computed$1, onScopeDispose as onScopeDispose$1, ref as ref$1, watch as watch$1 } from "vue";
 //#region src/error-reporting.ts
@@ -48,6 +48,8 @@ function useEditor(options) {
 		isLoading: false,
 		uiTheme: "auto"
 	});
+	const loadVersion = ref(0);
+	let loadingRequest = 0;
 	/**
 	* Bumped by every content mutation. `save()` captures it before awaiting the
 	* provider and only clears `isDirty` if it is unchanged afterwards, so an edit
@@ -252,6 +254,7 @@ function useEditor(options) {
 		const { create: providerCreate } = provider;
 		if (typeof providerCreate !== "function") refuse("create()", "is disabled by the provider — its `create` is `false`.");
 		let created;
+		const request = ++loadingRequest;
 		state.isLoading = true;
 		try {
 			if (input?.content) state.content = input.content;
@@ -262,31 +265,35 @@ function useEditor(options) {
 			} : { content: state.content });
 			state.template = created;
 			if (revision === revisionAtRequest) state.isDirty = false;
+			loadVersion.value++;
 		} catch (error) {
 			options.onError?.(error);
 			throw error;
 		} finally {
-			state.isLoading = false;
+			if (loadingRequest === request) state.isLoading = false;
 		}
 		notify(() => provider.onCreated?.(created));
 		return created;
 	}
-	async function load(templateId) {
+	async function load(templateId, shouldApply) {
 		const provider = requireProvider("load()");
 		let loaded;
+		const request = ++loadingRequest;
 		state.isLoading = true;
 		try {
 			loaded = await provider.load(templateId);
 			assertNoSlotInContent(loaded.content);
 			assertNoWrapperInContent(loaded.content);
+			if (shouldApply && !shouldApply()) return loaded;
 			state.template = loaded;
 			state.content = loaded.content;
 			state.isDirty = false;
+			loadVersion.value++;
 		} catch (error) {
 			options.onError?.(error);
 			throw error;
 		} finally {
-			state.isLoading = false;
+			if (loadingRequest === request) state.isLoading = false;
 		}
 		notify(() => provider.onLoaded?.(loaded));
 		return loaded;
@@ -328,6 +335,7 @@ function useEditor(options) {
 	}
 	return {
 		state: readonly(state),
+		loadVersion: readonly(loadVersion),
 		content,
 		selectedBlock,
 		isBlockLocked,
@@ -668,7 +676,7 @@ const NO_SKIP = /* @__PURE__ */ new Set();
 function containerKey(parent) {
 	return parent === null ? ROOT_KEY : JSON.stringify([parent.sectionId, parent.column]);
 }
-function columnsOf$1(block) {
+function columnsOf(block) {
 	const children = block.children;
 	return block.type === "section" && Array.isArray(children) ? children : [];
 }
@@ -682,7 +690,7 @@ function indexBlocks(blocks) {
 				key: containerKey(parent),
 				index
 			});
-			columnsOf$1(block).forEach((column, columnIndex) => {
+			columnsOf(block).forEach((column, columnIndex) => {
 				if (Array.isArray(column)) walk(column, {
 					sectionId: block.id,
 					column: columnIndex
@@ -767,7 +775,7 @@ function diffContent(before, after) {
 		return next !== void 0 && previous !== void 0 && next.block.type !== previous.block.type;
 	};
 	const survives = (block) => now.has(block.id) && !typeChanged(block.id);
-	const hasSurvivor = (block) => columnsOf$1(block).some((column) => Array.isArray(column) && column.some((child) => survives(child) || !typeChanged(child.id) && hasSurvivor(child)));
+	const hasSurvivor = (block) => columnsOf(block).some((column) => Array.isArray(column) && column.some((child) => survives(child) || !typeChanged(child.id) && hasSurvivor(child)));
 	const gone = /* @__PURE__ */ new Set();
 	const deferred = [];
 	const visit = (block, fate) => {
@@ -796,13 +804,13 @@ function diffContent(before, after) {
 				childFate = "dropped";
 			}
 		}
-		for (const column of columnsOf$1(block)) if (Array.isArray(column)) for (const child of column) visit(child, childFate);
+		for (const column of columnsOf(block)) if (Array.isArray(column)) for (const child of column) visit(child, childFate);
 	};
 	for (const block of before.blocks) visit(block, "kept");
 	const exists = (id) => was.has(id) && !gone.has(id);
 	const payloadOf = (block) => {
 		const payload = safeClone(block);
-		if (payload.type === "section") payload.children = columnsOf$1(block).map((column) => Array.isArray(column) ? column.filter((child) => !exists(child.id)).map((child) => safeClone(child)) : column);
+		if (payload.type === "section") payload.children = columnsOf(block).map((column) => Array.isArray(column) ? column.filter((child) => !exists(child.id)).map((child) => safeClone(child)) : column);
 		return payload;
 	};
 	const place = (parent, finalList, arrivedWithParent) => {
@@ -839,8 +847,8 @@ function diffContent(before, after) {
 	const resize = (grow) => {
 		for (const section of sections) {
 			if (!exists(section.id)) continue;
-			const fromCount = columnsOf$1(was.get(section.id).block).length;
-			const toCount = columnsOf$1(section).length;
+			const fromCount = columnsOf(was.get(section.id).block).length;
+			const toCount = columnsOf(section).length;
 			if (grow ? toCount > fromCount : toCount < fromCount) {
 				ops.push({
 					op: "updateBlock",
@@ -854,7 +862,7 @@ function diffContent(before, after) {
 	resize(true);
 	for (const section of sections) {
 		const isNew = !exists(section.id);
-		columnsOf$1(section).forEach((column, columnIndex) => {
+		columnsOf(section).forEach((column, columnIndex) => {
 			if (!Array.isArray(column)) return;
 			place({
 				sectionId: section.id,
@@ -886,141 +894,6 @@ function diffContent(before, after) {
 	});
 	return ops;
 }
-//#endregion
-//#region src/invert-operations.ts
-function columnsOf(block) {
-	const children = block.children;
-	return block.type === "section" && Array.isArray(children) ? children : [];
-}
-function positionOf(blocks, blockId, parent = null) {
-	for (let index = 0; index < blocks.length; index++) {
-		const block = blocks[index];
-		if (block.id === blockId) return {
-			block,
-			parent,
-			after: index > 0 ? blocks[index - 1].id : null
-		};
-		const columns = columnsOf(block);
-		for (let column = 0; column < columns.length; column++) {
-			if (!Array.isArray(columns[column])) continue;
-			const found = positionOf(columns[column], blockId, {
-				sectionId: block.id,
-				column
-			});
-			if (found) return found;
-		}
-	}
-	return null;
-}
-function requirePosition(state, blockId, index) {
-	const position = positionOf(state.blocks, blockId);
-	if (!position) throw new OperationError("block_missing", index, `No block with id "${blockId}".`, blockId);
-	return position;
-}
-/** Put back the keys an update touched, expecting what the update left. */
-function restoreKeys(current, set, unset) {
-	const restore = {};
-	const remove = [];
-	const expect = {};
-	const keys = [.../* @__PURE__ */ new Set([...Object.keys(set ?? {}), ...unset ?? []])];
-	for (const key of keys) {
-		const previous = current[key];
-		if (previous === void 0) remove.push(key);
-		else restore[key] = safeClone(previous);
-		const next = set && key in set ? set[key] : void 0;
-		expect[key] = next === void 0 ? null : safeClone(next);
-	}
-	return {
-		set: restore,
-		unset: remove,
-		expect
-	};
-}
-function invertOne(state, op, index) {
-	switch (op.op) {
-		case "addBlock": return {
-			op: "deleteBlock",
-			blockId: op.block.id,
-			expect: { block: safeClone(op.block) }
-		};
-		case "deleteBlock": {
-			const position = requirePosition(state, op.blockId, index);
-			return {
-				op: "addBlock",
-				block: safeClone(position.block),
-				parent: position.parent,
-				after: position.after
-			};
-		}
-		case "moveBlock": {
-			const position = requirePosition(state, op.blockId, index);
-			return {
-				op: "moveBlock",
-				blockId: op.blockId,
-				parent: position.parent,
-				after: position.after,
-				expect: {
-					parent: op.parent,
-					after: op.after
-				}
-			};
-		}
-		case "updateBlock": {
-			const block = requirePosition(state, op.blockId, index).block;
-			const { set, unset, expect } = restoreKeys(block, op.set, op.unset);
-			return {
-				op: "updateBlock",
-				blockId: op.blockId,
-				...Object.keys(set).length > 0 ? { set } : {},
-				...unset.length > 0 ? { unset } : {},
-				expect
-			};
-		}
-		case "updateSettings": {
-			const { set, unset, expect } = restoreKeys(state.settings, op.set, op.unset);
-			return {
-				op: "updateSettings",
-				...Object.keys(set).length > 0 ? { set } : {},
-				...unset.length > 0 ? { unset } : {},
-				expect
-			};
-		}
-		case "setContent": return {
-			op: "setContent",
-			content: {
-				blocks: safeClone(state.blocks),
-				settings: safeClone(state.settings)
-			}
-		};
-	}
-}
-/**
-* The batch that undoes `ops`, given the content they apply to. Each operation
-* is inverted against the content just before it, and the inverses run in
-* reverse order.
-*
-* Every inverse that can be guarded is: it expects what its operation left
-* behind, so an undo that a later edit by someone else has overtaken is refused
-* (`precondition_failed`, `anchor_missing`, `block_missing`) instead of
-* overwriting that edit. A `setContent` inverse has no guard; the backend's
-* `locked_by_others` rule is what stops it while others are editing.
-*
-* Throws the engine's `OperationError` when `ops` don't apply to `before`.
-*/
-function invertOperations(before, ops) {
-	const state = safeClone(before);
-	const inverses = [];
-	ops.forEach((op, index) => {
-		inverses.push(invertOne(state, op, index));
-		try {
-			applyOperationsInPlace(state, [op]);
-		} catch (error) {
-			if (!(error instanceof OperationError)) throw error;
-			throw new OperationError(error.code, index, error.message, error.blockId);
-		}
-	});
-	return inverses.reverse();
-}
 /** A revision that hasn't arrived after this long is fetched. */
 const COLLABORATION_GAP_TIMEOUT_MS = 1e3;
 /** A held lock is renewed this often; the backend lets it lapse after 30 s. */
@@ -1035,6 +908,8 @@ const RETRY_DELAYS_MS = [
 ];
 /** The snapshot history's depth, kept for the operation history too. */
 const DEFAULT_MAX_UNDO = 50;
+/** OperationBatch allows 1–100 operations. */
+const MAX_BATCH_OPS = 100;
 const REFUSAL_CODES = /* @__PURE__ */ new Set([
 	"block_exists",
 	"block_missing",
@@ -1264,7 +1139,7 @@ function useCollaboration(options) {
 				return;
 			}
 		}
-		const entry = { ops: invertOperations(session.view, ops) };
+		const entry = { ops: invertOperations$1(session.view, ops) };
 		pushCapped(session.undo, entry);
 		session.redo = [];
 		bumpHistory();
@@ -1272,14 +1147,20 @@ function useCollaboration(options) {
 		enqueue(session, ops, "edit", entry);
 	}
 	function enqueue(session, ops, origin, entry) {
-		session.pending.push({
-			batchId: crypto.randomUUID(),
-			ops,
-			origin,
-			entry,
-			sent: false,
-			revision: null
-		});
+		const group = { dropped: false };
+		let offset = 0;
+		do {
+			session.pending.push({
+				batchId: crypto.randomUUID(),
+				ops: ops.slice(offset, offset + MAX_BATCH_OPS),
+				origin,
+				entry,
+				group,
+				sent: false,
+				revision: null
+			});
+			offset += MAX_BATCH_OPS;
+		} while (offset < ops.length);
 		pump(session);
 	}
 	function pump(session) {
@@ -1297,7 +1178,8 @@ function useCollaboration(options) {
 		provider.submit(session.templateId, {
 			batchId: batch.batchId,
 			baseRevision: session.revision,
-			ops: batch.ops
+			ops: batch.ops,
+			...batch.origin === "ai" ? { origin: "ai" } : {}
 		}).then(({ revision: confirmedAt }) => {
 			session.inFlight = null;
 			confirmOwn(session, batch, confirmedAt);
@@ -1346,21 +1228,30 @@ function useCollaboration(options) {
 		}
 		bumpHistory();
 	}
+	function dropRefusedGroup(session, batch) {
+		const firstRefusal = !batch.group.dropped;
+		batch.group.dropped = true;
+		session.pending = session.pending.filter((pending) => pending.group !== batch.group || pending.sent);
+		if (firstRefusal) takeBackEntry(session, batch);
+		settleWaiters(session);
+		return firstRefusal;
+	}
 	function refuse(session, batch, error) {
 		dropPending(session, batch);
-		takeBackEntry(session, batch);
-		const code = refusalCode(error) ?? "invalid_operation";
-		if (batch.origin === "edit") {
-			const holder = refusalHolder(error);
-			notify({
-				type: "editRefused",
-				code,
-				...holder ? { holder } : {}
+		if (dropRefusedGroup(session, batch)) {
+			const code = refusalCode(error) ?? "invalid_operation";
+			if (batch.origin === "edit" || batch.origin === "ai") {
+				const holder = refusalHolder(error);
+				notify({
+					type: "editRefused",
+					code,
+					...holder ? { holder } : {}
+				}, session);
+			} else notify({
+				type: "undoSkipped",
+				code
 			}, session);
-		} else notify({
-			type: "undoSkipped",
-			code
-		}, session);
+		}
 		rebuild(session);
 		if (session === active) catchUp();
 	}
@@ -1399,6 +1290,7 @@ function useCollaboration(options) {
 	/** Apply whatever is next in revision order, own and remote alike. */
 	function drain(session) {
 		const applied = [];
+		let confirmedDroppedChunk = false;
 		for (;;) {
 			const at = session.revision + 1;
 			const remote = session.remote.get(at);
@@ -1422,13 +1314,14 @@ function useCollaboration(options) {
 				applied.push(remote);
 			} else {
 				session.own.delete(at);
+				if (own.group.dropped) confirmedDroppedChunk = true;
 				dropPending(session, own);
 			}
 		}
 		if (session === active) revision.value = session.revision;
 		if (session.remote.size > 0 || session.own.size > 0) armGapTimer(session);
 		else clearGapTimer(session);
-		if (applied.length === 0) return;
+		if (applied.length === 0 && !confirmedDroppedChunk) return;
 		rebuild(session);
 		if (session !== active) return;
 		for (const batch of applied) try {
@@ -1444,26 +1337,26 @@ function useCollaboration(options) {
 	function rebuild(session) {
 		if (session === active) flush();
 		let view = session.confirmed;
-		const kept = [];
-		for (const batch of session.pending) try {
-			view = applyOperations(view, batch.ops);
-			kept.push(batch);
-		} catch (error) {
-			if (batch.sent) {
-				kept.push(batch);
-				continue;
+		for (let index = 0; index < session.pending.length; index++) {
+			const batch = session.pending[index];
+			try {
+				view = applyOperations(view, batch.ops);
+			} catch (error) {
+				if (batch.sent) continue;
+				if (dropRefusedGroup(session, batch)) {
+					const code = error instanceof OperationError ? error.code : "invalid_operation";
+					notify(batch.origin === "edit" || batch.origin === "ai" ? {
+						type: "editRefused",
+						code
+					} : {
+						type: "undoSkipped",
+						code
+					}, session);
+				}
+				view = session.confirmed;
+				index = -1;
 			}
-			takeBackEntry(session, batch);
-			const code = error instanceof OperationError ? error.code : "invalid_operation";
-			notify(batch.origin === "edit" ? {
-				type: "editRefused",
-				code
-			} : {
-				type: "undoSkipped",
-				code
-			}, session);
 		}
-		session.pending = kept;
 		session.view = view;
 		settleWaiters(session);
 		if (session === active) renderView(view);
@@ -1781,13 +1674,55 @@ function useCollaboration(options) {
 			});
 			return;
 		}
-		const counter = { ops: invertOperations(session.view, entry.ops) };
+		const counter = { ops: invertOperations$1(session.view, entry.ops) };
 		pushCapped(direction === "undo" ? session.redo : session.undo, counter);
 		session.view = next;
 		renderView(next);
 		editor?.markDirty();
 		enqueue(session, entry.ops, direction, counter);
 	}
+	function applyFromTurn(ops, options) {
+		const session = active;
+		if (!editor || !session || suspended) return {
+			applied: false,
+			error: new OperationError("invalid_operation", 0, "No template is open for editing.")
+		};
+		flush();
+		let next;
+		let inverse;
+		try {
+			next = applyOperations(session.view, ops, lockContext());
+			inverse = invertOperations$1(session.view, ops);
+		} catch (error) {
+			if (error instanceof OperationError) return {
+				applied: false,
+				error
+			};
+			throw error;
+		}
+		const top = session.undo.at(-1);
+		let entry;
+		if (top && top.turn === options.turn) {
+			top.ops = [...inverse, ...top.ops];
+			entry = top;
+		} else {
+			entry = {
+				ops: inverse,
+				turn: options.turn
+			};
+			pushCapped(session.undo, entry);
+		}
+		session.redo = [];
+		bumpHistory();
+		session.view = next;
+		renderView(next);
+		editor.markDirty();
+		enqueue(session, ops, options.origin, entry);
+		return {
+			applied: true,
+			inverse
+		};
+	}
 	function attach(target) {
 		editor = target;
 		stopWatching.push(watch(() => target.state.template, (template) => switchTo(template), { immediate: true }), watch(() => target.content.value, scheduleCapture, { deep: true }), watch(() => target.state.selectedBlockId, onSelection), watch(() => target.state.isLoading, (loading) => loading ? capture(true, true) : scheduleCapture()));
@@ -1852,6 +1787,7 @@ function useCollaboration(options) {
 		resume,
 		catchUp,
 		hasConfirmedBlock: (blockId) => active ? containsBlock(active.confirmed.blocks, blockId) : false,
+		applyOperations: applyFromTurn,
 		destroy
 	};
 }